https://dl.acm.org/

Anyone have links to items here of particular interest to the D community?

On Tuesday, 31 March 2020 at 01:23:45 UTC, Walter Bright wrote:
> https://dl.acm.org/
>
> Anyone have links to items here of particular interest to the D community?

I just did a quick search, not sure about the quality, but there are some good results for the following areas:

- Garbage collection
- Modula-3
- Oberon
- Mesa/Cedar
- Singularity

So programming languages that overlap with D's goals, system languages with GC having being used on graphical workstation OS research, and the always discussed subject of using a GC in systems languages.

--
Paulo

On Tuesday, 31 March 2020 at 01:23:45 UTC, Walter Bright wrote:
> https://dl.acm.org/
>
> Anyone have links to items here of particular interest to the D community?

I haven't had the chance to read the whole paper, but from reading the abstract, it looks very strongly related to your work on @live:

https://dl.acm.org/doi/10.1007/978-3-642-11957-6_29

Direct download link: https://link.springer.com/content/pdf/10.1007%2F978-3-642-11957-6_29.pdf

On 3/30/2020 11:33 PM, Petar Kirov [ZombineDev] wrote:
> it looks very strongly related to your work on @live:
> 
> https://dl.acm.org/doi/10.1007/978-3-642-11957-6_29
> 
> Direct download link: https://link.springer.com/content/pdf/10.1007%2F978-3-642-11957-6_29.pdf

Thank you. Abstract is:

Stateful Contracts for Affine Types∗
Jesse A. Tov and Riccardo Pucella

Northeastern University, Boston, MA 02115, USA
{tov,riccardo}@ccs.neu.edu

Abstract. Affine type systems manage resources by preventing some
values from being used more than once. This offers expressiveness and
performance benefits, but difficulty arises in interacting with components
written in a conventional language whose type system provides no way
to maintain the affine type system’s aliasing invariants. We propose and
implement a technique that uses behavioral contracts to mediate between
code written in an affine language and code in a conventional typed
language. We formalize our approach via a typed calculus with both
affine-typed and conventionally-typed modules. We show how to preserve
the guarantees of both type systems despite both languages being able
to call into each other and exchange higher-order values.