<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" version="2.0">
  <channel>
    <title>ACM Queue - Programming Languages</title>
    <link>http://queue.acm.org/listing.cfm?item_topic=Programming Languages&amp;qc_type=topics_list&amp;filter=Programming Languages&amp;page_title=Programming Languages&amp;order=desc</link>
    <description />
    <item>
      <title>Optimizations in C++ Compilers</title>
      <link>http://queue.acm.org/detail.cfm?id=3372264</link>
      <description>There's a tradeoff to be made in giving the compiler more information: it can make compilation slower. Technologies such as link time optimization can give you the best of both worlds. Optimizations in compilers continue to improve, and upcoming improvements in indirect calls and virtual function dispatch might soon lead to even faster polymorphism.</description>
      <category>Programming Languages</category>
      <pubDate>Tue, 12 Nov 2019 15:18:04 GMT</pubDate>
      <author>Matt Godbolt</author>
      <guid isPermaLink="false">3372264</guid>
    </item>
    <item>
      <title>Garbage Collection as a Joint Venture</title>
      <link>http://queue.acm.org/detail.cfm?id=3325132</link>
      <description>Cross-component tracing is a way to solve the problem of reference cycles across component boundaries. This problem appears as soon as components can form arbitrary object graphs with nontrivial ownership across API boundaries. An incremental version of CCT is implemented in V8 and Blink, enabling effective and efficient reclamation of memory in a safe manner.</description>
      <category>Programming Languages</category>
      <pubDate>Tue, 09 Apr 2019 15:33:59 GMT</pubDate>
      <author>Ulan Degenbaev, Michael Lippautz, Hannes Payer</author>
      <guid isPermaLink="false">3325132</guid>
    </item>
    <item>
      <title>C Is Not a Low-level Language</title>
      <link>http://queue.acm.org/detail.cfm?id=3212479</link>
      <description>In the wake of the recent Meltdown and Spectre vulnerabilities, it's worth spending some time looking at root causes. Both of these vulnerabilities involved processors speculatively executing instructions past some kind of access check and allowing the attacker to observe the results via a side channel. The features that led to these vulnerabilities, along with several others, were added to let C programmers continue to believe they were programming in a low-level language, when this hasn't been the case for decades.</description>
      <category>Programming Languages</category>
      <pubDate>Mon, 30 Apr 2018 15:18:18 GMT</pubDate>
      <author>David Chisnall</author>
      <guid isPermaLink="false">3212479</guid>
    </item>
    <item>
      <title>Thou Shalt Not Depend on Me</title>
      <link>http://queue.acm.org/detail.cfm?id=3205288</link>
      <description>Most websites use JavaScript libraries, and many of them are known to be vulnerable. Understanding the scope of the problem, and the many unexpected ways that libraries are included, are only the first steps toward improving the situation. The goal here is that the information included in this article will help inform better tooling, development practices, and educational efforts for the community.</description>
      <category>Programming Languages</category>
      <pubDate>Wed, 04 Apr 2018 12:55:55 GMT</pubDate>
      <author>Tobias Lauinger, Abdelberi Chaabane, Christo Wilson</author>
      <guid isPermaLink="false">3205288</guid>
    </item>
    <item>
      <title>Uninitialized Reads</title>
      <link>http://queue.acm.org/detail.cfm?id=3041020</link>
      <description>Most developers understand that reading uninitialized variables in C is a defect, but some do it anyway. What happens when you read uninitialized objects is unsettled in the current version of the C standard (C11).3 Various proposals have been made to resolve these issues in the planned C2X revision of the standard. Consequently, this is a good time to understand existing behaviors as well as proposed revisions to the standard to influence the evolution of the C language. Given that the behavior of uninitialized reads is unsettled in C11, prudence dictates eliminating uninitialized reads from your code.</description>
      <category>Programming Languages</category>
      <pubDate>Mon, 16 Jan 2017 17:07:44 GMT</pubDate>
      <author>Robert C. Seacord</author>
      <guid isPermaLink="false">3041020</guid>
    </item>
    <item>
      <title>Why Logical Clocks are Easy</title>
      <link>http://queue.acm.org/detail.cfm?id=2917756</link>
      <description>Any computing system can be described as executing sequences of actions, with an action being any relevant change in the state of the system. For example, reading a file to memory, modifying the contents of the file in memory, or writing the new contents to the file are relevant actions for a text editor. In a distributed system, actions execute in multiple locations; in this context, actions are often called events. Examples of events in distributed systems include sending or receiving messages, or changing some state in a node. Not all events are related, but some events can cause and influence how other, later events occur. For example, a reply to a received mail message is influenced by that message, and maybe by prior messages received.</description>
      <category>Programming Languages</category>
      <pubDate>Tue, 12 Apr 2016 20:37:21 GMT</pubDate>
      <author>Carlos Baquero, Nuno Pregui&amp;#231;a</author>
      <guid isPermaLink="false">2917756</guid>
    </item>
    <item>
      <title>Spicing Up Dart with Side Effects</title>
      <link>http://queue.acm.org/detail.cfm?id=2747873</link>
      <description>The Dart programming language has recently incorporated a set of extensions designed to support asynchrony and generator functions. Because Dart is a language for Web programming, latency is an important concern. To avoid blocking, developers must make methods asynchronous when computing their results requires nontrivial time. Generator functions ease the task of computing iterable sequences.</description>
      <category>Programming Languages</category>
      <pubDate>Thu, 19 Mar 2015 15:43:01 GMT</pubDate>
      <author>Erik Meijer, Kevin Millikin, Gilad Bracha</author>
      <guid isPermaLink="false">2747873</guid>
    </item>
    <item>
      <title>META II: Digital Vellum in the Digital Scriptorium</title>
      <link>http://queue.acm.org/detail.cfm?id=2724586</link>
      <description>Some people do living history -- reviving older skills and material culture by reenacting Waterloo or knapping flint knives. One pleasant rainy weekend in 2012, I set my sights a little more recently and settled in for a little meditative retro-computing, ca. 1962, following the ancient mode of transmission of knowledge: lecture and recitation -- or rather, grace of living in historical times, lecture (here, in the French sense, reading) and transcription (or even more specifically, grace of living post-Post, lecture and reimplementation).</description>
      <category>Programming Languages</category>
      <pubDate>Wed, 21 Jan 2015 14:10:58 GMT</pubDate>
      <author>Dave Long</author>
      <guid isPermaLink="false">2724586</guid>
    </item>
    <item>
      <title>Design Exploration through Code-generating DSLs</title>
      <link>http://queue.acm.org/detail.cfm?id=2626374</link>
      <description>DSLs (domain-specific languages) make programs shorter and easier to write. They can be stand-alone - for example, LaTeX, Makefiles, and SQL - or they can be embedded in a host language. You might think that DSLs embedded in high-level languages would be abstract or mathematically oriented, far from the nitty-gritty of low-level programming. This is not the case. This article demonstrates how high-level EDSLs (embedded DSLs) really can ease low-level programming. There is no contradiction.</description>
      <category>Programming Languages</category>
      <pubDate>Thu, 15 May 2014 17:20:11 GMT</pubDate>
      <author>Bo Joel Svensson, Mary Sheeran, Ryan Newton</author>
      <guid isPermaLink="false">2626374</guid>
    </item>
    <item>
      <title>Domain-specific Languages and Code Synthesis Using Haskell</title>
      <link>http://queue.acm.org/detail.cfm?id=2617811</link>
      <description>There are many ways to give instructions to a computer: an electrical engineer might write a MATLAB program; a database administrator might write an SQL script; a hardware engineer might write in Verilog; and an accountant might write a spreadsheet with embedded formulas. Aside from the difference in language used in each of these examples, there is an important difference in form and idiom. Each uses a language customized to the job at hand, and each builds computational requests in a form both familiar and productive for programmers (although accountants may not think of themselves as programmers). In short, each of these examples uses a DSL (domain-specific language).</description>
      <category>Programming Languages</category>
      <pubDate>Tue, 06 May 2014 13:38:13 GMT</pubDate>
      <author>Andy Gill</author>
      <guid isPermaLink="false">2617811</guid>
    </item>
  </channel>
</rss>

