<?xml version="1.0" encoding="UTF-8"?>
 <rdf:RDF xmlns="http://purl.org/rss/1.0/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://web.resource.org/cc/" xmlns:syn="http://purl.org/rss/1.0/modules/syndication/" xmlns:admin="http://webns.net/mvcb/">
  <channel rdf:about="http://pinboard.in">
    <title>Pinboard (Vaguery)</title>
    <link>https://pinboard.in/u:Vaguery/public/</link>
    <description>recent bookmarks from Vaguery</description>
    <items>
      <rdf:Seq>	<rdf:li rdf:resource="https://arxiv.org/abs/2405.21047"/>
	<rdf:li rdf:resource="https://dl.acm.org/doi/full/10.1145/3674634"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2309.07932"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2210.13873"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2212.04320"/>
	<rdf:li rdf:resource="https://norvig.com/lispy.html"/>
	<rdf:li rdf:resource="https://manim-data-structures.readthedocs.io/en/latest/guides/arrays.html"/>
	<rdf:li rdf:resource="https://alarmingdevelopment.org/?p=1570"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1901.01930"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2010.12338"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1904.11121"/>
	<rdf:li rdf:resource="http://vldb.org/pvldb/"/>
	<rdf:li rdf:resource="https://rise.cs.berkeley.edu/"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1812.02243"/>
	<rdf:li rdf:resource="https://www.youtube.com/user/Computerphile/videos"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1608.03960"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2011.04483"/>
	<rdf:li rdf:resource="https://rowman.com/ISBN/9781538147061/Contingent-Computation-Abstraction-Experience-and-Indeterminacy-in-Computational-Aesthetics"/>
	<rdf:li rdf:resource="https://dl.acm.org/doi/abs/10.1145/3385412.3386037"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1905.03694"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1611.05513"/>
	<rdf:li rdf:resource="https://dl.acm.org/citation.cfm?id=3290320"/>
	<rdf:li rdf:resource="https://www.cl.cam.ac.uk/~afb21/"/>
	<rdf:li rdf:resource="https://disorderlylabs.github.io/"/>
	<rdf:li rdf:resource="https://dl.acm.org/citation.cfm?id=3302515&amp;picked=prox"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1902.03568"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1506.04349"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1901.04911"/>
	<rdf:li rdf:resource="https://www.researchgate.net/publication/221329427_Evolving_Algebras_and_Linear_Time_Hierarchy"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1808.06255"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1809.04209"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1811.00607"/>
	<rdf:li rdf:resource="https://en.wikipedia.org/wiki/Anytime_algorithm"/>
	<rdf:li rdf:resource="http://rbr.cs.umass.edu/shlomo/papers/ZRchapter95.pdf"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1811.09989"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1804.00746"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1808.07990"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1804.05578"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/cs/0610153"/>
	<rdf:li rdf:resource="http://www.solipsys.co.uk/new/WhenOptimisingCodeMeasure.html?RSS"/>
	<rdf:li rdf:resource="https://link.springer.com/chapter/10.1007/978-1-4899-5841-9_2"/>
	<rdf:li rdf:resource="https://cs.stackexchange.com/questions/44226/how-can-a-cyclic-tag-system-halt-with-an-output"/>
	<rdf:li rdf:resource="https://www.scottaaronson.com/blog/?p=3943"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1805.03374"/>
	<rdf:li rdf:resource="http://pharo.gforge.inria.fr/PBE1/PBE1ch10.html"/>
	<rdf:li rdf:resource="https://www.inferentialthinking.com/chapters/intro"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1801.10139"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1805.11813"/>
	<rdf:li rdf:resource="http://blog.alicegoldfuss.com/foot-candles/"/>
	<rdf:li rdf:resource="http://www.openproblemgarden.org/home"/>
	<rdf:li rdf:resource="https://lispcast.com/church-vs-curry-types/"/>
	<rdf:li rdf:resource="https://cseweb.ucsd.edu/~goguen/projs/semio.html"/>
	<rdf:li rdf:resource="https://boingboing.net/2012/09/12/magic-the-gathering.html"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1711.03363"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.08800"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1208.2764"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1610.00331"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1208.2771"/>
	<rdf:li rdf:resource="http://published.eptcs.org/"/>
	<rdf:li rdf:resource="http://www.sciencedirect.com/science/article/pii/S1571066103500020"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.04494"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.02252"/>
	<rdf:li rdf:resource="http://www.sciencedirect.com/science/article/pii/030439759500024Q"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1705.00317"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1102.5683"/>
	<rdf:li rdf:resource="http://programming-journal.org/purpose/"/>
	<rdf:li rdf:resource="http://search.arxiv.org:8081/paper.jsp?r=1501.06328&amp;qid=1490097869827ler_nCnN_397128995&amp;qs=%22recreational+math%22+OR+%22recreational+mathematics%22+OR+%22mathematical+recreations%22&amp;byDate=1"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1701.03308"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1701.07615"/>
	<rdf:li rdf:resource="https://github.com/engelberg/instaparse"/>
      </rdf:Seq>
    </items>
  </channel><item rdf:about="https://arxiv.org/abs/2405.21047">
    <title>[2405.21047] Grammar-Aligned Decoding</title>
    <dc:date>2026-06-10T17:21:31+00:00</dc:date>
    <link>https://arxiv.org/abs/2405.21047</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Large Language Models (LLMs) struggle with reliably generating highly structured outputs, such as program code, mathematical formulas, or well-formed markup. Constrained decoding approaches mitigate this problem by greedily restricting what tokens an LLM can output at each step to guarantee that the output matches a given constraint. Specifically, in grammar-constrained decoding (GCD), the LLM's output must follow a given grammar. In this paper, we demonstrate that GCD techniques (and in general constrained decoding techniques) can distort the LLM's distribution, leading to outputs that are grammatical but appear with likelihoods that are not proportional to the ones given by the LLM, and so ultimately are low-quality. We call the problem of aligning sampling with a grammar constraint, grammar-aligned decoding (GAD), and propose adaptive sampling with approximate expected futures (ASAp), a decoding algorithm that guarantees the output to be grammatical while provably producing outputs that match the conditional probability of the LLM's distribution conditioned on the given grammar constraint. Our algorithm uses prior sample outputs to soundly overapproximate the future grammaticality of different output prefixes. Our evaluation on code generation and structured NLP tasks shows how ASAp often produces outputs with higher likelihood (according to the LLM's distribution) than existing GCD techniques, while still enforcing the desired grammatical constraints.
]]></description>
<dc:subject>computer-science neural-networks natural-language-processing LLMs grammar constraint-satisfaction hey-I-know-this-guy GPTP2026 consider:genetic-programming</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:bff828266dd3/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:natural-language-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:LLMs"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:grammar"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:constraint-satisfaction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:hey-I-know-this-guy"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:GPTP2026"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:genetic-programming"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://dl.acm.org/doi/full/10.1145/3674634">
    <title>The Long Way to Deforestation: A Type Inference and Elaboration Technique for Removing Intermediate Data Structures | Proceedings of the ACM on Programming Languages</title>
    <dc:date>2026-02-25T22:06:02+00:00</dc:date>
    <link>https://dl.acm.org/doi/full/10.1145/3674634</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[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.
]]></description>
<dc:subject>computer-science symbolic-analysis formal-languages functional-programming to-understand computational-complexity efficiency consider:Push</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:e124ca6a05b6/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:symbolic-analysis"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:functional-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:efficiency"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:Push"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2309.07932">
    <title>[2309.07932] Flat origami is Turing Complete</title>
    <dc:date>2026-01-01T01:00:43+00:00</dc:date>
    <link>https://arxiv.org/abs/2309.07932</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Flat origami" refers to the folding of flat, zero-curvature paper such that the finished object lies in a plane. Mathematically, flat origami consists of a continuous, piecewise isometric map f:P⊆ℝ2→ℝ2 along with a layer ordering λf:P×P→{−1,1} that tracks which points of P are above/below others when folded. The set of crease lines that a flat origami makes (i.e., the set on which the mapping f is non-differentiable) is called its "crease pattern." Flat origami mappings and their layer orderings can possess surprisingly intricate structure. For instance, determining whether or not a given straight-line planar graph drawn on P is the crease pattern for some flat origami has been shown to be an NP-complete problem, and this result from 1996 led to numerous explorations in computational aspects of flat origami. In this paper we prove that flat origami, when viewed as a computational device, is Turing complete, or more specifically P-complete. We do this by showing that flat origami crease patterns with "optional creases" (creases that might be folded or remain unfolded depending on constraints imposed by other creases or inputs) can be constructed to simulate Rule 110, a one-dimensional cellular automaton that was proven to be Turing complete by Matthew Cook in 2004.]]></description>
<dc:subject>origami computer-science turing-completeness proof cellular-automata indistinguishable-from-magic to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1349898c7d78/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:origami"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:turing-completeness"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:proof"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cellular-automata"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:indistinguishable-from-magic"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2210.13873">
    <title>[2210.13873] Program Synthesis Using Example Propagation</title>
    <dc:date>2025-04-16T18:56:40+00:00</dc:date>
    <link>https://arxiv.org/abs/2210.13873</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We present Scrybe, an example-based synthesis tool for a statically-typed functional programming language, which combines top-down deductive reasoning in the style of λ2 with Smyth-style live bidirectional evaluation. During synthesis, example constraints are propagated through sketches to prune and guide the search. This enables Scrybe to make more effective use of functions provided in the context. To evaluate our tool, it is run on the combined, largely disjoint, benchmarks of λ2 and Myth. Scrybe is able to synthesize most of the combined benchmark tasks.
]]></description>
<dc:subject>program-synthesis type-theory computer-science the-other-kind-of-learning-from-data to-understand mathematical-programming consider:representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c061e6eb7ae8/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:program-synthesis"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:type-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:the-other-kind-of-learning-from-data"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:mathematical-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:representation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2212.04320">
    <title>[2212.04320] A 65nm 8b-Activation 8b-Weight SRAM-Based Charge-Domain Computing-in-Memory Macro Using A Fully-Parallel Analog Adder Network and A Single-ADC Interface</title>
    <dc:date>2024-11-01T19:14:15+00:00</dc:date>
    <link>https://arxiv.org/abs/2212.04320</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Performing data-intensive tasks in the von Neumann architecture is challenging to achieve both high performance and power efficiency due to the memory wall bottleneck. Computing-in-memory (CiM) is a promising mitigation approach by enabling parallel in-situ multiply-accumulate (MAC) operations within the memory with support from the peripheral interface and datapath. SRAM-based charge-domain CiM (CD-CiM) has shown its potential of enhanced power efficiency and computing accuracy. However, existing SRAM-based CD-CiM faces scaling challenges to meet the throughput requirement of high-performance multi-bit-quantization applications. This paper presents an SRAM-based high-throughput ReLU-optimized CD-CiM macro. It is capable of completing MAC and ReLU of two signed 8b vectors in one CiM cycle with only one A/D conversion. Along with non-linearity compensation for the analog computing and A/D conversion interfaces, this work achieves 51.2GOPS throughput and 10.3TOPS/W energy efficiency, while showing 88.6% accuracy in the CIFAR-10 dataset.
]]></description>
<dc:subject>algorithms computer-science architecture to-understand unconventional-computing acceleration computational-complexity consider:genetic-programming</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c7c2b27eeb14/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:unconventional-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:acceleration"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:genetic-programming"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://norvig.com/lispy.html">
    <title>(How to Write a (Lisp) Interpreter (in Python))</title>
    <dc:date>2024-06-24T12:06:14+00:00</dc:date>
    <link>https://norvig.com/lispy.html</link>
    <dc:creator>Vaguery</dc:creator><dc:subject>learning-by-doing parsing computer-science basics</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:9568e60dc05f/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:learning-by-doing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:parsing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:basics"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://manim-data-structures.readthedocs.io/en/latest/guides/arrays.html">
    <title>Animating Arrays - Manim Data Structures v0.1.7</title>
    <dc:date>2024-06-18T10:44:06+00:00</dc:date>
    <link>https://manim-data-structures.readthedocs.io/en/latest/guides/arrays.html</link>
    <dc:creator>Vaguery</dc:creator><dc:subject>Manim animation documentation explanation to-use plugin computer-science</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:62954927dbf8/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Manim"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:animation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:documentation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:explanation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-use"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:plugin"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://alarmingdevelopment.org/?p=1570">
    <title>Version Control for Structure Editing – Alarming Development</title>
    <dc:date>2021-10-26T13:54:59+00:00</dc:date>
    <link>https://alarmingdevelopment.org/?p=1570</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[With this work I am finally confronting the demon cursing my work: version control. If we are to liberate programming from text we need to make structure editing work, including version control. After all, there will be limited benefit from structure editing if collaboration forces us to return to text editing. It feels like this chronic problem has been dragging me down forever. I’ve spent endless effort trying to handle differencing and merging with embedded unique IDs, but I never got it fully worked out, and it remained as technical “dark matter” clogging all my projects. I finally had to accept that the whole approach wasn’t working, and start over.

]]></description>
<dc:subject>computer-science version-control rather-interesting data-structures user-experience archives to-understand consider:visualization consider:DAG-of-a-book</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2595566926a8/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:version-control"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-structures"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:user-experience"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:archives"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:visualization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:DAG-of-a-book"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1901.01930">
    <title>[1901.01930] Keeping CALM: When Distributed Consistency is Easy</title>
    <dc:date>2021-07-11T20:39:53+00:00</dc:date>
    <link>https://arxiv.org/abs/1901.01930</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[A key concern in modern distributed systems is to avoid the cost of coordination while maintaining consistent semantics. Until recently, there was no answer to the question of when coordination is actually required. In this paper we present an informal introduction to the CALM Theorem, which answers this question precisely by moving up from traditional storage consistency to consider properties of programs. 
CALM is an acronym for "consistency as logical monotonicity". The CALM Theorem shows that the programs that have consistent, coordination-free distributed implementations are exactly the programs that can be expressed in monotonic logic. This theoretical result has practical implications for developers of distributed applications. We show how CALM provides a constructive application-level counterpart to conventional "systems" wisdom, such as the apparently negative results of the CAP Theorem. We also discuss ways that monotonic thinking can influence distributed systems design, and how new programming language designs and tools can help developers write consistent, coordination-free code.
]]></description>
<dc:subject>distributed-processing to-understand computer-science formalization programming-language computational-complexity</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:f3379ddde585/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formalization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2010.12338">
    <title>[2010.12338] Adjoint Reactive GUI</title>
    <dc:date>2021-06-27T12:21:17+00:00</dc:date>
    <link>https://arxiv.org/abs/2010.12338</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Most interaction with a computer is done via a graphical user interface. Traditionally, these are implemented in an imperative fashion using shared mutable state and callbacks. This is efficient, but is also difficult to reason about and error prone. Functional Reactive Programming (FRP) provides an elegant alternative which allows GUIs to be designed in a declarative fashion. However, most FRP languages are synchronous and continually check for new data. This means that an FRP-style GUI will "wake up" on each program cycle. This is problematic for applications like text editors and browsers, where often nothing happens for extended periods of time, and we want the implementation to sleep until new data arrives. In this paper, we present an asynchronous FRP language for designing GUIs called λ𝖶𝗂𝖽𝗀𝖾𝗍. Our language provides a novel semantics for widgets, the building block of GUIs, which offers both a natural Curry--Howard logical interpretation and an efficient implementation strategy.
]]></description>
<dc:subject>computer-science programming-language representation asynchronous-dynamics to-understand consider:ReQ consider:interpreter-design</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:3f76028e7837/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:asynchronous-dynamics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:ReQ"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:interpreter-design"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1904.11121">
    <title>[1904.11121] Declarative Recursive Computation on an RDBMS, or, Why You Should Use a Database For Distributed Machine Learning</title>
    <dc:date>2021-06-27T10:20:34+00:00</dc:date>
    <link>https://arxiv.org/abs/1904.11121</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[A number of popular systems, most notably Google's TensorFlow, have been implemented from the ground up to support machine learning tasks. We consider how to make a very small set of changes to a modern relational database management system (RDBMS) to make it suitable for distributed learning computations. Changes include adding better support for recursion, and optimization and execution of very large compute plans. We also show that there are key advantages to using an RDBMS as a machine learning platform. In particular, learning based on a database management system allows for trivial scaling to large data sets and especially large models, where different computational units operate on different parts of a model that may be too large to fit into RAM.
]]></description>
<dc:subject>machine-learning databases representation rather-interesting SQL computer-science the-tools-at-hand to-write-about to-simulate consider:partial-sim consider:embedding</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b008d7aaadce/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:databases"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:SQL"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:the-tools-at-hand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-simulate"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:partial-sim"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:embedding"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://vldb.org/pvldb/">
    <title>Proceedings of the VLDB Endowment</title>
    <dc:date>2021-05-23T11:42:46+00:00</dc:date>
    <link>http://vldb.org/pvldb/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[PVLDB is a scholarly journal for short and timely research papers with a journal-style reviewing and quality-assurance process. PVLDB is owned by the VLDB Endowment and publicized by the ACM Digital Library. PVLDB allows continuous submissions throughout the year. In addition to being accepted or rejected, submissions may also have revisions requested and invited for further review. Regardless of the submission type, all accepted papers are uniformly published in the next available issue of PVLDB and will be offered a presentation slot at the next available VLDB conference. Accepted papers will be published in PVLDB only.

]]></description>
<dc:subject>journal databases rather-interesting computer-science short-papers</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:89aa4189b1ce/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:journal"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:databases"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:short-papers"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://rise.cs.berkeley.edu/">
    <title>RISELab at UC Berkeley - REAL-TIME INTELLIGENT SECURE EXECUTION</title>
    <dc:date>2021-05-22T12:48:08+00:00</dc:date>
    <link>https://rise.cs.berkeley.edu/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[REAL-TIME INTELLIGENT SECURE EXPLAINABLE SYSTEMS
IN THE RISELAB, WE DEVELOP TECHNOLOGIES THAT ENABLE APPLICATIONS TO MAKE LOW-LATENCY DECISIONS ON LIVE DATA WITH STRONG SECURITY]]></description>
<dc:subject>machine-learning computer-science interpretability usability rather-interesting</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:ed40653240ec/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:interpretability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:usability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1812.02243">
    <title>[1812.02243] Gems of Corrado Böhm</title>
    <dc:date>2021-04-28T12:17:39+00:00</dc:date>
    <link>https://arxiv.org/abs/1812.02243</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The main scientific heritage of Corrado Böhm consists of ideas about computing, concerning concrete algorithms, as well as models of computability. The following will be presented. 1. A compiler that can compile itself. 2. Structured programming, eliminating the 'goto' statement. 3. Functional programming and an early implementation. 4. Separability in {\lambda}-calculus. 5. Compiling combinators without parsing. 6. Self-evaluation in {\lambda}-calculus.
]]></description>
<dc:subject>computer-science history-of-science rather-interesting explanation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:5c1948e4d449/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:history-of-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:explanation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.youtube.com/user/Computerphile/videos">
    <title>Computerphile - YouTube</title>
    <dc:date>2021-04-28T10:57:24+00:00</dc:date>
    <link>https://www.youtube.com/user/Computerphile/videos</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Computerphile]]></description>
<dc:subject>computer-science video to-watch rather-good</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:dabfbf84c220/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:video"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-watch"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-good"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1608.03960">
    <title>[1608.03960] A Conflict-Free Replicated JSON Datatype</title>
    <dc:date>2020-12-07T21:41:46+00:00</dc:date>
    <link>https://arxiv.org/abs/1608.03960</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Many applications model their data in a general-purpose storage format such as JSON. This data structure is modified by the application as a result of user input. Such modifications are well understood if performed sequentially on a single copy of the data, but if the data is replicated and modified concurrently on multiple devices, it is unclear what the semantics should be. In this paper we present an algorithm and formal semantics for a JSON data structure that automatically resolves concurrent modifications such that no updates are lost, and such that all replicas converge towards the same state (a conflict-free replicated datatype or CRDT). It supports arbitrarily nested list and map types, which can be modified by insertion, deletion and assignment. The algorithm performs all merging client-side and does not depend on ordering guarantees from the network, making it suitable for deployment on mobile devices with poor network connectivity, in peer-to-peer networks, and in messaging systems with end-to-end encryption.
]]></description>
<dc:subject>computer-science concurrency data-structures rather-interesting to-understand to-implement consider:ReQ-concurrency consider:worst-cases</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c1b77ce94a20/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:concurrency"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-structures"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-implement"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:ReQ-concurrency"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:worst-cases"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2011.04483">
    <title>[2011.04483] A Theory of Universal Learning</title>
    <dc:date>2020-11-25T20:47:10+00:00</dc:date>
    <link>https://arxiv.org/abs/2011.04483</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[How quickly can a given class of concepts be learned from examples? It is common to measure the performance of a supervised machine learning algorithm by plotting its "learning curve", that is, the decay of the error rate as a function of the number of training examples. However, the classical theoretical framework for understanding learnability, the PAC model of Vapnik-Chervonenkis and Valiant, does not explain the behavior of learning curves: the distribution-free PAC model of learning can only bound the upper envelope of the learning curves over all possible data distributions. This does not match the practice of machine learning, where the data source is typically fixed in any given scenario, while the learner may choose the number of training examples on the basis of factors such as computational resources and desired accuracy. 
In this paper, we study an alternative learning model that better captures such practical aspects of machine learning, but still gives rise to a complete theory of the learnable in the spirit of the PAC model. More precisely, we consider the problem of universal learning, which aims to understand the performance of learning algorithms on every data distribution, but without requiring uniformity over the distribution. The main result of this paper is a remarkable trichotomy: there are only three possible rates of universal learning. More precisely, we show that the learning curves of any given concept class decay either at an exponential, linear, or arbitrarily slow rates. Moreover, each of these cases is completely characterized by appropriate combinatorial parameters, and we exhibit optimal learning algorithms that achieve the best possible rate in each case. 
For concreteness, we consider in this paper only the realizable case, though analogous results are expected to extend to more general learning scenarios.
]]></description>
<dc:subject>via:cshalizi machine-learning computer-science information-theory to-understand in-theory-and-in-practice</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:9fae184e05bc/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:cshalizi"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:information-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:in-theory-and-in-practice"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://rowman.com/ISBN/9781538147061/Contingent-Computation-Abstraction-Experience-and-Indeterminacy-in-Computational-Aesthetics">
    <title>Contingent Computation: Abstraction, Experience, and Indeterminacy in Computational Aesthetics - 9781538147061</title>
    <dc:date>2020-11-08T23:13:35+00:00</dc:date>
    <link>https://rowman.com/ISBN/9781538147061/Contingent-Computation-Abstraction-Experience-and-Indeterminacy-in-Computational-Aesthetics</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In Contingent Computation, M. Beatrice Fazi offers a new theoretical perspective through which we can engage philosophically with computing. The book proves that aesthetics is a viable mode of investigating contemporary computational systems. It does so by advancing an original conception of computational aesthetics that does not just concern art made by or with computers, but rather the modes of being and becoming of computational processes. Contingent Computation mobilises the philosophies of Gilles Deleuze and Alfred North Whitehead in order to address aesthetics as an ontological study of the generative potential of reality. Through a novel philosophical reading of Gödel’s incompleteness theorems and of Turing’s notion of incomputability, Fazi finds this potential at the formal heart of computational systems, and argues that computation is a process of determining indeterminacy. This indeterminacy, which is central to computational systems, does not contradict their functionality. Instead, it drives their very operation, albeit in a manner that might not always fit with the instrumental, representational and cognitivist purposes that we have assigned to computing. 
]]></description>
<dc:subject>books computer-science philosophy representation to-read nonstandard-computational-frameworks</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:73dc8198f1bd/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:books"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:philosophy"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-read"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nonstandard-computational-frameworks"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://dl.acm.org/doi/abs/10.1145/3385412.3386037">
    <title>Towards an API for the real numbers | Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation</title>
    <dc:date>2020-11-01T12:09:49+00:00</dc:date>
    <link>https://dl.acm.org/doi/abs/10.1145/3385412.3386037</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[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.
Although this is entirely appropriate for many applications, particularly those that are sensitive to arithmetic performance in the usual sense, we argue that there are others where it is a poor choice. If arithmetic computations and result are directly exposed to human users who are not floating point experts, floating point approximations tend to be viewed as bugs. For applications such as calculators, spreadsheets, and various verification tasks, the cost of precision sacrifices is high, and the performance benefit is often not critical. We argue that previous attempts to provide accurate and understandable results for such applications using the recursive reals were great steps in the right direction, but they do not suffice. Comparing recursive reals diverges if they are equal. In many cases, comparison of numbers, including equal ones, is both important, particularly in simple cases, and intractable in the general case.
We propose an API for a real number type that explicitly provides decidable equality in the easy common cases, in which it is often unnatural not to. We describe a surprisingly compact and simple implementation in detail. The approach relies heavily on classical number theory results. We demonstrate the utility of such a facility in two applications: testing floating point functions, and to implement arithmetic in Google's Android calculator application.]]></description>
<dc:subject>computer-science representation number-theory rather-interesting API to-understand to-write-about mathematics philosophy-of-engineering</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:e018a87cf481/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:number-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:API"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:mathematics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:philosophy-of-engineering"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1905.03694">
    <title>[1905.03694] Supervised Online Hashing via Hadamard Codebook Learning</title>
    <dc:date>2019-12-29T10:45:04+00:00</dc:date>
    <link>https://arxiv.org/abs/1905.03694</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In recent years, binary code learning, a.k.a hashing, has received extensive attention in large-scale multimedia retrieval. It aims to encode high-dimensional data points to binary codes, hence the original high-dimensional metric space can be efficiently approximated via Hamming space. However, most existing hashing methods adopted offline batch learning, which is not suitable to handle incremental datasets with streaming data or new instances. In contrast, the robustness of the existing online hashing remains as an open problem, while the embedding of supervised/semantic information hardly boosts the performance of the online hashing, mainly due to the defect of unknown category numbers in supervised learning. In this paper, we proposed an online hashing scheme, termed Hadamard Codebook based Online Hashing (HCOH), which aims to solve the above problems towards robust and supervised online hashing. In particular, we first assign an appropriate high-dimensional binary codes to each class label, which is generated randomly by Hadamard codes to each class label, which is generated randomly by Hadamard codes. Subsequently, LSH is adopted to reduce the length of such Hadamard codes in accordance with the hash bits, which can adapt the predefined binary codes online, and theoretically guarantee the semantic similarity. Finally, we consider the setting of stochastic data acquisition, which facilitates our method to efficiently learn the corresponding hashing functions via stochastic gradient descend (SGD) online. Notably, the proposed HCOH can be embedded with supervised labels and it not limited to a predefined category number. Extensive experiments on three widely-used benchmarks demonstrate the merits of the proposed scheme over the state-of-the-art methods. The code is available at this https URL.
]]></description>
<dc:subject>representation hashing computer-science rather-odd machine-learning to-understand indirection</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:aec3f4c4b442/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:hashing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-odd"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:indirection"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1611.05513">
    <title>[1611.05513] Dilated Floor Functions That Commute</title>
    <dc:date>2019-09-07T11:38:52+00:00</dc:date>
    <link>https://arxiv.org/abs/1611.05513</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We determine all pairs of real numbers (α,β) such that the dilated floor functions ⌊αx⌋ and ⌊βx⌋ commute under composition, i.e., such that ⌊α⌊βx⌋⌋=⌊β⌊αx⌋⌋ holds for all real x.
]]></description>
<dc:subject>number-theory computer-science define-your-terms constraint-satisfaction to-write-about to-simulate consider:looking-for-pairs consider:classification-of-pairs</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:a69a50c803ed/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:number-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:define-your-terms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:constraint-satisfaction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-simulate"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:looking-for-pairs"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:classification-of-pairs"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://dl.acm.org/citation.cfm?id=3290320">
    <title>Intersection types and runtime errors in the pi-calculus</title>
    <dc:date>2019-06-12T14:15:49+00:00</dc:date>
    <link>https://dl.acm.org/citation.cfm?id=3290320</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[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 Π20-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.
]]></description>
<dc:subject>type-theory to-understand can't-wait-to-understand pi-calculus concurrency formal-languages computer-science abstraction-kisses-the-neck-of-necessity</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2c1710be0c6f/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:type-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:can't-wait-to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:pi-calculus"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:concurrency"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:abstraction-kisses-the-neck-of-necessity"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.cl.cam.ac.uk/~afb21/">
    <title>Alan Blackwell - Home Page</title>
    <dc:date>2019-04-25T15:26:14+00:00</dc:date>
    <link>https://www.cl.cam.ac.uk/~afb21/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[[inaccessible home page goes here]]]></description>
<dc:subject>computer-science system-of-professions homepage to-talk-to see-paper no-really-bad-a11y</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:58771a939876/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:system-of-professions"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:homepage"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-talk-to"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:see-paper"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:no-really-bad-a11y"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://disorderlylabs.github.io/">
    <title>Disorderly Labs</title>
    <dc:date>2019-04-17T11:57:21+00:00</dc:date>
    <link>https://disorderlylabs.github.io/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Distributed systems are difficult to program and near impossible to debug. Existing tools that focus on single-node computation are poorly-suited to diagnose errors that involve the interaction of many machines over time. The database notion of provenance would appear better suited to answering the sort of cause-and-effect questions that arise during debugging, but existing provenance-based approaches target only a narrow set of debugging scenarios. In this paper, we explore the limits of provenance-based debugging. We propose a simple query language to express common debugging questions as expressions over provenance graphs capturing traces of distributed executions. We show how when programs and their correctness properties are written in a high-level declarative language, we can go a step further than highlighting errors and generate repairs for distributed programs. We validate our prototype debugger, Nemo, on six protocols from our taxonomy of 52 real-world distributed bugs, either generating repair rules or pointing the programmer to root causes.
]]></description>
<dc:subject>computer-science testing distributed-systems heuristics rather-interesting algorithms to-understand</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:10ddf6d7716c/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:testing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:heuristics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://dl.acm.org/citation.cfm?id=3302515&amp;picked=prox">
    <title>Proceedings of the ACM on Programming Languages</title>
    <dc:date>2019-04-13T11:17:02+00:00</dc:date>
    <link>https://dl.acm.org/citation.cfm?id=3302515&amp;picked=prox</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Proceedings of the ACM on Programming Languages
Volume 3 Issue POPL, January 2019 table of contents]]></description>
<dc:subject>computer-science programming-language formal-languages to-try-to-understand-some-day rather-interesting</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:93db73e5e316/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-try-to-understand-some-day"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1902.03568">
    <title>[1902.03568] Balancing Straight-Line Programs</title>
    <dc:date>2019-04-10T11:05:12+00:00</dc:date>
    <link>https://arxiv.org/abs/1902.03568</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[It is shown that a context-free grammar of size m that produces a single string w (such a grammar is also called a string straight-line program) can be transformed in linear time into a context-free grammar for w of size (m), whose unique derivation tree has depth (log|w|). This solves an open problem in the area of grammar-based compression. Similar results are shown for two formalism for grammar-based tree compression: top dags and forest straight-line programs. These balancing results are all deduced from a single meta theorem stating that the depth of an algebraic circuit over an algebra with a certain finite base property can be reduced to (logn) with the cost of a constant multiplicative size increase. Here, n refers to the size of the unfolding (or unravelling) of the circuit.
]]></description>
<dc:subject>computer-science representation grammars rather-interesting compression rewriting-systems computational-complexity</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c220f5b47e0d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:grammars"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:compression"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rewriting-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1506.04349">
    <title>[1506.04349] Rare Speed-up in Automatic Theorem Proving Reveals Tradeoff Between Computational Time and Information Value</title>
    <dc:date>2019-03-02T13:05:58+00:00</dc:date>
    <link>https://arxiv.org/abs/1506.04349</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We show that strategies implemented in automatic theorem proving involve an interesting tradeoff between execution speed, proving speedup/computational time and usefulness of information. We advance formal definitions for these concepts by way of a notion of normality related to an expected (optimal) theoretical speedup when adding useful information (other theorems as axioms), as compared with actual strategies that can be effectively and efficiently implemented. We propose the existence of an ineluctable tradeoff between this normality and computational time complexity. The argument quantifies the usefulness of information in terms of (positive) speed-up. The results disclose a kind of no-free-lunch scenario and a tradeoff of a fundamental nature. The main theorem in this paper together with the numerical experiment---undertaken using two different automatic theorem provers AProS and Prover9 on random theorems of propositional logic---provide strong theoretical and empirical arguments for the fact that finding new useful information for solving a specific problem (theorem) is, in general, as hard as the problem (theorem) itself.]]></description>
<dc:subject>computer-science theorem-provers no-free-lunch performance-measure looking-to-see rather-interesting multiobjective-optimization it's-more-complicated-than-you-think</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c2a1f0c0837d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:theorem-provers"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:no-free-lunch"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:performance-measure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:looking-to-see"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:multiobjective-optimization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:it's-more-complicated-than-you-think"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1901.04911">
    <title>[1901.04911] Unconstrained Church-Turing thesis cannot possibly be true</title>
    <dc:date>2019-02-14T02:04:06+00:00</dc:date>
    <link>https://arxiv.org/abs/1901.04911</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The Church-Turing thesis asserts that if a partial strings-to-strings function is effectively computable then it is computable by a Turing machine. 
In the 1930s, when Church and Turing worked on their versions of the thesis, there was a robust notion of algorithm. These traditional algorithms are known also as classical or sequential. In the original thesis, effectively computable meant computable by an effective classical algorithm. Based on an earlier axiomatization of classical algorithms, the original thesis was proven in 2008. 
Since the 1930s, the notion of algorithm has changed dramatically. New species of algorithms have been and are being introduced. We argue that the generalization of the original thesis, where effectively computable means computable by an effective algorithm of any species, cannot possibly be true.
]]></description>
<dc:subject>computer-science rewriting-systems formal-languages computability algorithms to-understand</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:fcd6115f4c84/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rewriting-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.researchgate.net/publication/221329427_Evolving_Algebras_and_Linear_Time_Hierarchy">
    <title>(PDF) Evolving Algebras and Linear Time Hierarchy</title>
    <dc:date>2019-02-14T02:02:34+00:00</dc:date>
    <link>https://www.researchgate.net/publication/221329427_Evolving_Algebras_and_Linear_Time_Hierarchy</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The paper discusses evolving algebras and their linear time hierarchy. The first result is a universal ealgebra and the main result is the diagonalization theorem for ealgebras implying the linear time hierarchy theorem. Other machine models are also considered whose external function is the nullary function and one has to work harder to derive the diagonalization and linear time hierarchy theorems for these machines.
]]></description>
<dc:subject>computer-science rewriting-systems formal-languages to-understand ReQ programming-language abstraction lecture-notes</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:aeb85eb6b989/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rewriting-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:abstraction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:lecture-notes"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1808.06255">
    <title>[1808.06255] Evolving Algebras 1993: Lipari Guide</title>
    <dc:date>2019-02-14T02:00:20+00:00</dc:date>
    <link>https://arxiv.org/abs/1808.06255</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Computation models and specification methods seem to be worlds apart. The project on abstract state machines (in short ASMs, also known as evolving algebras) started as an attempt to bridge the gap by improving on Turing's thesis. We sought more versatile machines which would be able to step-for-step simulate arbitrary algorithms on their natural abstraction levels. The ASM thesis asserts that ASMs are such versatile machines. The guide provides the definitions of sequential, parallel and distributed ASMs.
]]></description>
<dc:subject>formal-languages computer-science formal-logic programming-language abstraction to-understand</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:092f2f5152eb/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-logic"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:abstraction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1809.04209">
    <title>[1809.04209] Bidirectional Evaluation with Direct Manipulation</title>
    <dc:date>2019-02-13T11:37:37+00:00</dc:date>
    <link>https://arxiv.org/abs/1809.04209</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[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.
]]></description>
<dc:subject>rather-interesting usability functional-languages computer-science programming-language to-understand inference ReQ genetic-programming consider:GP</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:3367e7773c8d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:usability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:functional-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:inference"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:genetic-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:GP"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1811.00607">
    <title>[1811.00607] Exploring the Equivalence between Dynamic Dataflow Model and Gamma - General Abstract Model for Multiset mAnipulation</title>
    <dc:date>2019-02-13T11:25:37+00:00</dc:date>
    <link>https://arxiv.org/abs/1811.00607</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[With the increase of the search for computational models where the expression of parallelism occurs naturally, some paradigms arise as options for the next generation of computers. In this context, dynamic Dataflow and Gamma - General Abstract Model for Multiset mAnipulation) - emerge as interesting computational models choices. In the dynamic Dataflow model, operations are performed as soon as their associated operators are available, without rely on a Program Counter to dictate the execution order of instructions. The Gamma paradigm is based on a parallel multiset rewriting scheme. It provides a non-deterministic execution model inspired by an abstract chemical machine metaphor, where operations are formulated as reactions that occur freely among matching elements belonging to the multiset. In this work, equivalence relations between the dynamic Dataflow and Gamma paradigms are exposed and explored, while methods to convert from Dataflow to Gamma paradigm and vice versa are provided. It is shown that vertices and edges of a dynamic Dataflow graph can correspond, respectively, to reactions and multiset elements in the Gamma paradigm. Implementation aspects of execution environments that could be mutually beneficial to both models are also discussed. This work provides the scientific community with the possibility of taking profit of both parallel programming models, contributing with a versatility component to researchers and developers. Finally, it is important to state that, to the best of our knowledge, the similarity relations between both dynamic Dataflow and Gamma models presented here have not been reported in any previous work.
]]></description>
<dc:subject>concurrency rather-interesting to-understand coordination computer-science ReQ</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8c471d392413/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:concurrency"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:coordination"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://en.wikipedia.org/wiki/Anytime_algorithm">
    <title>Anytime algorithm - Wikipedia</title>
    <dc:date>2019-01-24T00:58:04+00:00</dc:date>
    <link>https://en.wikipedia.org/wiki/Anytime_algorithm</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In computer science, an anytime algorithm is an algorithm that can return a valid solution to a problem even if it is interrupted before it ends. The algorithm is expected to find better and better solutions the longer it keeps running.
Most algorithms run to completion: they provide a single answer after performing some fixed amount of computation. In some cases, however, the user may wish to terminate the algorithm prior to completion. The amount of computation required may be substantial, for example, and computational resources might need to be reallocated. Most algorithms either run to completion or they provide no useful solution information. Anytime algorithms, however, are able to return a partial answer, whose quality depends on the amount of computation they were able to perform. The answer generated by anytime algorithms is an approximation of the correct answer.
]]></description>
<dc:subject>via:nprnncbl algorithms computer-science rather-interesting to-understand ReQ approximation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:370b65503520/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:nprnncbl"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:approximation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://rbr.cs.umass.edu/shlomo/papers/ZRchapter95.pdf">
    <title>[PDF] APPROXIMATE REASONING USING ANYTIME ALGORITHMS</title>
    <dc:date>2019-01-24T00:50:12+00:00</dc:date>
    <link>http://rbr.cs.umass.edu/shlomo/papers/ZRchapter95.pdf</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The complexity of reasoning in intelligent systems makes it undesirable, and some- times infeasible, to find the optimal action in every situation since the deliberation process itself degrades the performance of the system. The problem is then to con- struct intelligent systems that react to a situation after performing the “right” amount of thinking. It is by now widely accepted that a successful system must trade off decision quality against the computational requirements of decision-making. Anytime algorithms, introduced by Dean, Horvitz and others in the late 1980’s, were designed to offer such a trade-off. We have extended their work to the construction of complex systems that are composed of anytime algorithms. This paper describes the compila- tion and monitoring mechanisms that are required to build intelligent systems that can efficiently control their deliberation time. We present theoretical results showing that the compilation and monitoring problems are tractable in a wide range of cases, and provide two applications to illustrate the ideas.]]></description>
<dc:subject>computer-science representation algorithms rather-interesting to-do to-understand ReQ approximation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:5eff90dde974/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-do"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:approximation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1811.09989">
    <title>[1811.09989] The dry history of liquid computers</title>
    <dc:date>2019-01-05T13:49:08+00:00</dc:date>
    <link>https://arxiv.org/abs/1811.09989</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[A liquid can be used to represent signals, actuate mechanical computing devices and to modify signals via chemical reactions. We give a brief overview of liquid based computing devices developed over hundreds of years. These include hydraulic calculators, fluidic computers, micro-fluidic devices, droplets, liquid marbles and reaction-diffusion chemical computers.
]]></description>
<dc:subject>nontraditional-computing representation algorithms out-of-the-box review history computer-science engineering-design to-write-about to-simulate</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:0b3266c41a99/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nontraditional-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:out-of-the-box"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:review"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:history"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-simulate"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1804.00746">
    <title>[1804.00746] The simple essence of automatic differentiation</title>
    <dc:date>2019-01-05T13:33:31+00:00</dc:date>
    <link>https://arxiv.org/abs/1804.00746</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[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.]]></description>
<dc:subject>computer-science differentiation gradients numerical-methods machine-learning algorithms category-theory rather-interesting to-understand</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b58c16300db7/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:differentiation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:gradients"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:numerical-methods"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:category-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1808.07990">
    <title>[1808.07990] Making Bubbling Practical</title>
    <dc:date>2018-12-20T12:33:44+00:00</dc:date>
    <link>https://arxiv.org/abs/1808.07990</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Bubbling is a run-time graph transformation studied for the execution of non-deterministic steps in functional logic computations. This transformation has been proven correct, but as currently formulated it requires information about the entire context of a step, even when the step affects only a handful of nodes. Therefore, despite some advantages, it does not appear to be competitive with approaches that require only localized information, such as backtracking and pull-tabbing. We propose a novel algorithm that executes bubbling steps accessing only local information. To this aim, we define graphs that have an additional attribute, a dominator of each node, and we maintain this attribute when a rewrite and/or bubbling step is executed. When a bubbling step is executed, the dominator is available at no cost, and only local information is accessed. Our work makes bubbling practical, and theoretically competitive, for implementing non-determinism in functional logic computations.]]></description>
<dc:subject>functional-languages computer-science programming-language remarkably-legible rewriting-systems representation dynamical-systems ReQ</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:f77ce970f164/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:functional-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:remarkably-legible"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rewriting-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:dynamical-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1804.05578">
    <title>[1804.05578] Probabilistic Rewriting: Relations between Normalization, Termination, and Unique Normal Forms</title>
    <dc:date>2018-12-17T13:32:46+00:00</dc:date>
    <link>https://arxiv.org/abs/1804.05578</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We adapt to the probabilistic setting techniques from Rewrite Theory, to gain a better understanding of the operational properties of calculi whose evaluation is both probabilistic and non-deterministic. The non-determinism we have in mind is that of parallelism, which arises from a choice between several redexes (think of lambda-calculus). In this context, questions such as "is the result unique?", or "is there a strategy to find a result with greatest probability?" are natural and computationally important. 
We investigate how the asymptotic behavior of different rewrite sequences starting from the same term compare w.r.t. normal forms, and we develop methods to study and compare strategies. Our approach is that of Abstract Rewrite Systems, we search for general properties of probabilistic rewriting, which hold independently of the specific nature of the objects. 
As an application, we study a lambda calculus, equipped with call-by-value weak evaluation and a probabilistic choice.
]]></description>
<dc:subject>probabilistic-languages lambda-calculus rewriting-systems computer-science programming-language to-understand formal-languages ReQ</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:859bcb9f3a77/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:probabilistic-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:lambda-calculus"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rewriting-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/cs/0610153">
    <title>[cs/0610153] Most Programs Stop Quickly or Never Halt</title>
    <dc:date>2018-12-10T12:42:43+00:00</dc:date>
    <link>https://arxiv.org/abs/cs/0610153</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Since many real-world problems arising in the fields of compiler optimisation, automated software engineering, formal proof systems, and so forth are equivalent to the Halting Problem--the most notorious undecidable problem--there is a growing interest, not only academically, in understanding the problem better and in providing alternative solutions. Halting computations can be recognised by simply running them; the main difficulty is to detect non-halting programs. Our approach is to have the probability space extend over both space and time and to consider the probability that a random N-bit program has halted by a random time. We postulate an a priori computable probability distribution on all possible runtimes and we prove that given an integer k>0, we can effectively compute a time bound T such that the probability that an N-bit program will eventually halt given that it has not halted by T is smaller than 2^{-k}. We also show that the set of halting programs (which is computably enumerable, but not computable) can be written as a disjoint union of a computable set and a set of effectively vanishing probability. Finally, we show that ``long'' runtimes are effectively rare. More formally, the set of times at which an N-bit program can stop after the time 2^{N+constant} has effectively zero density.
]]></description>
<dc:subject>halting-problem computer-science rather-interesting looking-to-see to-write-about ReQ computational-complexity probability-theory</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:ee2f564a31fb/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:halting-problem"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:looking-to-see"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:probability-theory"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.solipsys.co.uk/new/WhenOptimisingCodeMeasure.html?RSS">
    <title>When Optimising Code Measure</title>
    <dc:date>2018-12-09T13:16:17+00:00</dc:date>
    <link>http://www.solipsys.co.uk/new/WhenOptimisingCodeMeasure.html?RSS</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This is a truism that lots of people quote, but it can be hard to remember, especially in the heat of battle (as it were). Rather fortunately it came to mind just when needed, as I found something completely unexpected.

I was writing a simple implementation of the Fermat difference of squares method of factoring. This involves writing the number to be factored as - you guessed it - the difference of two squares. If n=a2−b2
n
=
a
2
−
b
2
 then n=(a−b)(a+b)
n
=
(
a
−
b
)
(
a
+
b
)
 and we have a factorisation (provided we don't have a−b=1
a
−
b
=
1
).]]></description>
<dc:subject>the-mangle-in-practice looking-to-see learning-in-public computer-science computational-complexity rather-interesting to-write-about contingency</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:a8e0f238aafd/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:the-mangle-in-practice"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:looking-to-see"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:learning-in-public"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:contingency"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://link.springer.com/chapter/10.1007/978-1-4899-5841-9_2">
    <title>Stochastic Computing Systems | SpringerLink</title>
    <dc:date>2018-12-09T11:20:44+00:00</dc:date>
    <link>https://link.springer.com/chapter/10.1007/978-1-4899-5841-9_2</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The invention of the steam engine in the late eighteenth century made it possible to replace the muscle-power of men and animals by the motive power of machines. The invention of the stored-program digital computer during the second world war made it possible to replace the lower-level mental processes of man, such as arithmetic computation and information storage, by electronic data-processing in machines. We are now coming to the stage where it is reasonable to contemplate replacing some of the higher mental processes of man, such as the ability to recognize patterns and to learn, with similar capabilities in machines. However, we lack the “steam engine” or “digital computer” which will provide the necessary technology for learning and pattern recognition by machines.]]></description>
<dc:subject>representation numerical-methods floating-point computer-science rather-interesting to-write-about nudge-targets consider:ReQ</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:48a2be0de095/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:numerical-methods"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:floating-point"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:ReQ"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://cs.stackexchange.com/questions/44226/how-can-a-cyclic-tag-system-halt-with-an-output">
    <title>computability - How can a cyclic tag system halt with an output? - Computer Science Stack Exchange</title>
    <dc:date>2018-11-26T13:26:36+00:00</dc:date>
    <link>https://cs.stackexchange.com/questions/44226/how-can-a-cyclic-tag-system-halt-with-an-output</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[How can a cyclic tag system halt with an output?]]></description>
<dc:subject>computer-science representation to-write-about ReQ</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:984bc4db0a67/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.scottaaronson.com/blog/?p=3943">
    <title>Shtetl-Optimized » Blog Archive » Lecture notes! Intro to Quantum Information Science</title>
    <dc:date>2018-11-05T11:00:29+00:00</dc:date>
    <link>https://www.scottaaronson.com/blog/?p=3943</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In Spring 2017, I taught a new undergraduate course at UT Austin, entitled Introduction to Quantum Information Science.  There were about 60 students, mostly CS but also with strong representation from physics, math, and electrical engineering.  One student, Ewin Tang, made a previous appearance on this blog.  But today belongs to another student, Paulo Alves, who took it upon himself to make detailed notes of all of my lectures.  Using Paulo’s notes as a starting point, and after a full year of procrastination and delays, I’m now happy to release the full lecture notes for the course.  Among other things, I’ll be using these notes when I teach the course a second time, starting … holy smokes … this Wednesday.

]]></description>
<dc:subject>syllabus quantum-computing computer-science class to-read</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:df36c5dadc2b/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:syllabus"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:quantum-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:class"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-read"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1805.03374">
    <title>[1805.03374] A Proposal for Loop-Transformation Pragmas</title>
    <dc:date>2018-11-04T13:15:28+00:00</dc:date>
    <link>https://arxiv.org/abs/1805.03374</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Pragmas for loop transformations, such as unrolling, are implemented in most mainstream compilers. They are used by application programmers because of their ease of use compared to directly modifying the source code of the relevant loops. We propose additional pragmas for common loop transformations that go far beyond the transformations today's compilers provide and should make most source rewriting for the sake of loop optimization unnecessary. To encourage compilers to implement these pragmas, and to avoid a diversity of incompatible syntaxes, we would like to spark a discussion about an inclusion to the OpenMP standard.
]]></description>
<dc:subject>computer-science compilers rewriting-systems refactoring rather-interesting to-understand computational-complexity optimization</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:cf30b8a40470/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:compilers"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rewriting-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:refactoring"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:optimization"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://pharo.gforge.inria.fr/PBE1/PBE1ch10.html">
    <title>9 Collections</title>
    <dc:date>2018-10-19T12:01:29+00:00</dc:date>
    <link>http://pharo.gforge.inria.fr/PBE1/PBE1ch10.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The collection classes form a loosely-defined group of general-purpose subclasses of Collection and Stream. The group of classes that appears in the “Blue Book” 1 contains 17 subclasses of Collection and 9 subclasses of Stream, for a total of 28 classes, and had already been redesigned several times before the Smalltalk-80 system was released. This group of classes is often considered to be a paradigmatic example of object-oriented design.

]]></description>
<dc:subject>languages Smalltalk classes computer-science nudge consider:robustness to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2e710e87a4f2/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Smalltalk"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:classes"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:robustness"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.inferentialthinking.com/chapters/intro">
    <title>Computational and Inferential Thinking - Data 8 Textbook</title>
    <dc:date>2018-10-07T18:20:54+00:00</dc:date>
    <link>https://www.inferentialthinking.com/chapters/intro</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Computational and Inferential Thinking]]></description>
<dc:subject>online-learning Jupyter textbook computer-science book rather-interesting to-read open-source</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:ff1fca15704a/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:online-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Jupyter"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:textbook"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:book"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-read"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:open-source"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1801.10139">
    <title>[1801.10139] Analysis of the Continued Logarithm Algorithm</title>
    <dc:date>2018-07-04T11:36:41+00:00</dc:date>
    <link>https://arxiv.org/abs/1801.10139</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The Continued Logarithm Algorithm - CL for short- introduced by Gosper in 1978 computes the gcd of two integers; it seems very efficient, as it only performs shifts and subtractions. Shallit has studied its worst-case complexity in 2016 and showed it to be linear. We here perform the average-case analysis of the algorithm: we study its main parameters (number of iterations, total number of shifts) and obtain precise asymptotics for their mean values. Our 'dynamical' analysis involves the dynamical system underlying the algorithm, that produces continued fraction expansions whose quotients are powers of 2. Even though this CL system has already been studied by Chan (around 2005), the presence of powers of 2 in the quotients ingrains into the central parameters a dyadic flavour that cannot be grasped solely by studying the CL system. We thus introduce a dyadic component and deal with a two-component system. With this new mixed system at hand, we then provide a complete average-case analysis of the CL algorithm, with explicit constants.]]></description>
<dc:subject>number-theory numerical-methods representation computer-science computational-complexity rather-interesting algorithms continued-fractions to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:af8dd74d354b/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:number-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:numerical-methods"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:continued-fractions"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1805.11813">
    <title>[1805.11813] Derivatives of Turing machines in Linear Logic</title>
    <dc:date>2018-06-21T10:22:07+00:00</dc:date>
    <link>https://arxiv.org/abs/1805.11813</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We calculate denotations under the Sweedler semantics of the Ehrhard-Regnier derivatives of various encodings of Turing machines into linear logic. We show that these derivatives calculate the rate of change of probabilities naturally arising in the Sweedler semantics of linear logic proofs. The resulting theory is applied to the problem of synthesising Turing machines by gradient descent.
]]></description>
<dc:subject>computer-science representation to-understand rather-interesting</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8ea6c87d6d94/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://blog.alicegoldfuss.com/foot-candles/">
    <title>Foot-candles: the different paths to tech – Alice Goldfuss</title>
    <dc:date>2018-05-26T14:02:34+00:00</dc:date>
    <link>http://blog.alicegoldfuss.com/foot-candles/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The deeper you dive into programming, the more you will run into topics covered by CS degrees. This may make you feel extremely behind and out of your depth. When this happens, keep the following in mind:

Your lack of knowledge in these topics doesn’t negate the work you’ve already done.
You know things CS grads don’t.
It’s likely your understanding of the topic is fresher and more complete than a CS grad who hasn’t touched it in years.
Everyone learns things in different orders and at different times, including CS grads.
Some things you will never need to know.
]]></description>
<dc:subject>imposter-syndrome computer-science system-of-professions careering worklife self-definition to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:fc9249a0e2a8/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:imposter-syndrome"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:system-of-professions"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:careering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:worklife"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:self-definition"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.openproblemgarden.org/home">
    <title>Home | Open Problem Garden</title>
    <dc:date>2018-03-24T11:37:00+00:00</dc:date>
    <link>http://www.openproblemgarden.org/home</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Welcome to the Open Problem Garden, a collection of unsolved problems in mathematics. Here you may:

Read descriptions of open problems.
Post comments on them.
Create and edit open problems pages (please contact us and we will set you up an account. Unfortunately, the automatic process is too prone to spammers at this moment.)]]></description>
<dc:subject>open-problems mathematical-recreations mathematics computer-science to-write-about nudge-targets</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:7ad233883a1d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:open-problems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:mathematical-recreations"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:mathematics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://lispcast.com/church-vs-curry-types/">
    <title>Church vs Curry Types - LispCast</title>
    <dc:date>2018-03-17T14:38:17+00:00</dc:date>
    <link>https://lispcast.com/church-vs-curry-types/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[My ambitious hope is that this perspective will quiet a lot of the fighting as people recognize that they are just perpetuating a rift in the field of mathematics that happened a long time ago. The perspectives are irreconcilable now, but that could change. A paper called Church and Curry: Combining Intrinsic and Extrinsic Typing builds a language with both kinds of types. And Gradual Typing and Blame Calculus are investigating the intersection of static and dynamic typing. Let’s stop fighting, make some cool tools and use them well.

]]></description>
<dc:subject>type-theory computer-science models-and-modes dichotomy-or-not? to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:21599c14588a/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:type-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:models-and-modes"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:dichotomy-or-not?"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://cseweb.ucsd.edu/~goguen/projs/semio.html">
    <title>Algebraic Semiotics</title>
    <dc:date>2018-02-24T11:47:09+00:00</dc:date>
    <link>https://cseweb.ucsd.edu/~goguen/projs/semio.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Algebraic semiotics is a new approach to meaning and representation, and in particular to user interface design, that builds on five important insights from the last hundred years:

Semiotics: Signs are not isolated items; they come in systems, and the structure of a sign is to a great extent inherited from the system to which it belongs. Signs do not have pre-given "Platonic" meanings, but rather their meaning is relational, because signs are always interpreted in particular contexts. (The first sentence reflects the influence of Saussure, the second that of Pierce.)
Social Context: Signs are used by people as part of their participation in social groups; meaning is primarily a social phenomenon; its purpose is communication. (This reflects some concerns of post-structuralism.)
Morphisms: If some class of objects is interesting, then structure preserving maps or morphisms of those objects are also interesting - perhaps even more so. For semiotics, these morphisms are representations. Objects and morphisms together form structures known as categories.
Blending and Colimits: If some class of objects is interesting, then putting those objects together in various ways is probably also interesting. Morphisms can be used to indicate that certain subojects are to be shared in such constructions, and colimits of various kinds are a category theoretic formalization of ways to put objects together. In cognitive linguistics, blending has been identified as an important way to combine conceptual systems.
Algebraic Specification: Sign systems and their morphisms can be described and studied in a precise way using semantic methods based on equational logic that were developed for the theory of abstract data types.
]]></description>
<dc:subject>semiotics user-interface user-experience digital-humanities computer-science engineering-design rather-interesting to-understand to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:7104c1992a0e/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:semiotics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:user-interface"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:user-experience"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:digital-humanities"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://boingboing.net/2012/09/12/magic-the-gathering.html">
    <title>Magic: The Gathering is Turing complete / Boing Boing</title>
    <dc:date>2018-02-19T13:19:12+00:00</dc:date>
    <link>https://boingboing.net/2012/09/12/magic-the-gathering.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Alex Churchill has posted a way to implement a Turing complete computer within a game of Magic: The Gathering ("Turing complete" is a way of classifying a calculating engine that is capable of general-purpose computation). The profound and interesting thing about the recurrence of Turing completeness in many unexpected places -- such as page-layout descriptive engines -- is that it suggests that there's something foundational about the ability to do general computation. It also suggests that attempts to limit general computation will be complicated by the continued discovery of new potential computing engines. That is, even if you lock down all the PCs so that they only play restricted music formats and not Ogg, if you allow a sufficiently speedy and scriptable Magic: The Gathering program to exist, someone may implement the Ogg player using collectible card games.

]]></description>
<dc:subject>computational-complexity computer-science amusing proof unconventional-representation-schemes</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:f8027ab2e255/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:amusing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:proof"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:unconventional-representation-schemes"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1711.03363">
    <title>[1711.03363] What Is Decidable about String Constraints with the ReplaceAll Function</title>
    <dc:date>2018-01-26T12:32:33+00:00</dc:date>
    <link>https://arxiv.org/abs/1711.03363</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[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.]]></description>
<dc:subject>formal-logic computational-complexity computer-science to-understand rather-odd system-of-professions to-translate</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:d4322438632b/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-logic"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-odd"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:system-of-professions"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-translate"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.08800">
    <title>[1709.08800] TuringMobile: A Turing Machine of Oblivious Mobile Robots with Limited Visibility and its Applications</title>
    <dc:date>2018-01-26T12:29:28+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.08800</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper we investigate the computational power of a set of mobile robots with limited visibility. At each iteration, a robot takes a snapshot of its surroundings, uses the snapshot to compute a destination point, and it moves toward its destination. Each robot is punctiform and memoryless, it operates in ℝm, it has a local reference system independent of the other robots' ones, and is activated asynchronously by an adversarial scheduler. Moreover, robots are non-rigid, in that they may be stopped by the scheduler at each move before reaching their destination (but are guaranteed to travel at least a fixed unknown distance before being stopped). 
We show that despite these strong limitations, it is possible to arrange 3m+3k of these weak entities in ℝm to simulate the behavior of a stronger robot that is rigid (i.e., it always reaches its destination) and is endowed with k registers of persistent memory, each of which can store a real number. We call this arrangement a TuringMobile. In its simplest form, a TuringMobile consisting of only three robots can travel in the plane and store and update a single real number. We also prove that this task is impossible with fewer than three robots. 
Among the applications of the TuringMobile, we focused on Near-Gathering (all robots have to gather in a small-enough disk) and Pattern Formation (of which Gathering is a special case) with limited visibility. Interestingly, our investigation implies that both problems are solvable in Euclidean spaces of any dimension, even if the visibility graph of the robots is initially disconnected, provided that a small amount of these robots are arranged to form a TuringMobile. In the special case of the plane, a basic TuringMobile of only three robots is sufficient.]]></description>
<dc:subject>artificial-life swarms rather-interesting computer-science computational-complexity to-simulate to-write-about emergent-design distributed-processing nudge-targets</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:e7ac1be6472f/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:artificial-life"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:swarms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-simulate"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:emergent-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1208.2764">
    <title>[1208.2764] Linear functional classes over cellular automata</title>
    <dc:date>2017-10-20T12:10:55+00:00</dc:date>
    <link>https://arxiv.org/abs/1208.2764</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Cellular automata are a discrete dynamical system which models massively parallel computation. Much attention is devoted to computations with small time complexity for which the parallelism may provide further possibilities. In this paper, we investigate the ability of cellular automata related to functional computation. We introduce several functional classes of low time complexity which contain "natural" problems. We examine their inclusion relationships and emphasize that several questions arising from this functional framework are related to current ones coming from the recognition context. We also provide a negative result which explicits limits on the information transmission whose consequences go beyond the functional point of view.]]></description>
<dc:subject>cellular-automata formal-languages rather-interesting computer-science computability to-understand</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:25bc959b5421/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cellular-automata"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:formal-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1610.00331">
    <title>[1610.00331] Comparing 1D and 2D Real Time on Cellular Automata</title>
    <dc:date>2017-10-20T11:55:57+00:00</dc:date>
    <link>https://arxiv.org/abs/1610.00331</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We study the influence of the dimension of cellular automata (CA) for real time language recognition of one-dimensional languages with parallel input. Specifically, we focus on the question of determining whether every language that can be recognized in real time on a 2-dimensional CA working on the Moore neighborhood can also be recognized in real time by a 1-dimensional CA working on the standard two-way neighborhood. 
We show that 2-dimensional CA in real time can perform a linear number of simulations of a 1-dimensional real time CA. If the two classes are equal then the number of simulated instances can be polynomial.]]></description>
<dc:subject>cellular-automata rather-interesting alternative-computational-models distributed-processing computer-science universality representation feature-construction engineering-design to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:02e93e71c942/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cellular-automata"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:alternative-computational-models"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:universality"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:feature-construction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1208.2771">
    <title>[1208.2771] A Universal Semi-totalistic Cellular Automaton on Kite and Dart Penrose Tilings</title>
    <dc:date>2017-10-20T11:34:34+00:00</dc:date>
    <link>https://arxiv.org/abs/1208.2771</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper we investigate certain properties of semi-totalistic cellular automata (CA) on the well known quasi-periodic kite and dart two dimensional tiling of the plane presented by Roger Penrose. We show that, despite the irregularity of the underlying grid, it is possible to devise a semi-totalistic CA capable of simulating any boolean circuit on this aperiodic tiling.]]></description>
<dc:subject>cellular-automata tiling computer-science universality rather-interesting to-write-about to-simulate</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:6ec6fc2edd86/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cellular-automata"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:tiling"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:universality"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-simulate"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://published.eptcs.org/">
    <title>Electronic Proceedings in Theoretical Computer Science Published Volumes</title>
    <dc:date>2017-10-19T11:24:21+00:00</dc:date>
    <link>http://published.eptcs.org/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[oh dear lord]]></description>
<dc:subject>to-read conferences proceedings nudge-targets computer-science to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:907443739b8a/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-read"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:conferences"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:proceedings"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.sciencedirect.com/science/article/pii/S1571066103500020">
    <title>Cumulative Computing - ScienceDirect</title>
    <dc:date>2017-10-09T11:11:57+00:00</dc:date>
    <link>http://www.sciencedirect.com/science/article/pii/S1571066103500020</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper we use the concept of resource cumulation to model various forms of computation. The space of cumulations (called a cumulator) is simply represented as a five tuple consisting of a well-founded partial order, a monoid and a volume function. The volume function is introduced to simplify reasoning about limit points and other topological properties. A specification command is a set of cumulations. Typical phenomena of concurrency such as reactiveness, safety and liveness, fairness, real time and branching time naturally arise from the model. In order to support a programming theory, we introduce a specification language that incorporates sequentiality, nondeterminism, simple parallelism, negation and general recursions. A new fixpoint technique is used to model general recursions. The language is applied to the case study on CSP, which becomes a special model of cumulative computing with a combination of four resource cumulators of alphabet, termination, trace and refusal. All laws of cumulative computing are also valid for CSP and the generalization from CSP to Timed CSP can be achieved by simply combining the four cumulators with real time. Loops whose bodies may take zero time can then be modeled more satisfactorily.
]]></description>
<dc:subject>computer-science to-understand concurrency representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:e037d20c7854/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:concurrency"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.04494">
    <title>[1709.04494] A Rewriting System for Convex Optimization Problems</title>
    <dc:date>2017-09-26T14:39:03+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.04494</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We describe a modular rewriting system for translating optimization problems written in a domain-specific language to forms compatible with low-level solver interfaces. Translation is facilitated by reductions, which accept a category of problems and transform instances of that category to equivalent instances of another category. Our system proceeds in two key phases: analysis, in which we attempt to find a suitable solver for a supplied problem, and canonicalization, in which we rewrite the problem in the selected solver's standard form. We implement the described system in version 1.0 of CVXPY, a domain-specific language for mathematical and especially convex optimization. By treating reductions as first-class objects, our method makes it easy to match problems to solvers well-suited for them and to support solvers with a wide variety of standard forms.
]]></description>
<dc:subject>domain-specific-languages rewriting-systems computer-science representation rather-interesting mathematical-programming algorithms define-your-terms</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:52e985438c99/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:domain-specific-languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rewriting-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:mathematical-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:define-your-terms"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.02252">
    <title>[1709.02252] A Geometric Approach to Harmonic Color Palette Design</title>
    <dc:date>2017-09-23T14:03:24+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.02252</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We address the problem of finding harmonic colors, this problem has many applications, from fashion to industrial design. In order to solve this problem we consider that colors follow normal distributions in tone (chroma and lightness) and hue. The proposed approach relies in the CIE standard for representing colors and evaluate proximity. Other approaches to this problem use a set of rules. Experimental results show that lines with specific parameters angles of inclination, and distance from the reference point are preferred over others, and that uncertain line patterns outperform non-linear patterns.
]]></description>
<dc:subject>color-theory rather-interesting define-your-terms graphic-design aesthetics numerical-methods computer-science algorithms nudge-targets consider:looking-to-see consider:performance-measures</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:4de08662162d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:color-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:define-your-terms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:graphic-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:aesthetics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:numerical-methods"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:looking-to-see"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:performance-measures"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.sciencedirect.com/science/article/pii/030439759500024Q">
    <title>Principles of programming with complex objects and collection types - ScienceDirect</title>
    <dc:date>2017-09-23T12:16:23+00:00</dc:date>
    <link>http://www.sciencedirect.com/science/article/pii/030439759500024Q</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We present a new principle for the development of database query languages that the primitive operations should be organized around types. Viewing a relational database as consisting of sets of records, this principle dectates that we should investigate separately operations for records and sets. There are two immediate advantages of this approach, which is partly inspired by basic ideas from category theoryl. First, it provides a language for structures in which record and set types may be freely combined: nested relations or complex objects. Second, the fundamental operations for sets are closely related to those for other “collection types” such as bags or lists, and this suggests how database languages may be uniformly extended to these new types.

the most general operation on sets, that of structural recursion, is one in which not all programs are well-defined. In looking for limited forms of this operation that always give rise to well-defined operations, we find a number of close connection with exiting database languages, notably those developed for complex objects. Moreover, even though the general paradigm of structural recursion is shown to be no more expressive than one of the existing languages for complex objects, it possesses certain properties of uniformity that make it a better candidate for an efficient, practical language. Thus rather than developing query languages by extending, for example, relational calculus, we advocate a very powerful paradigm in which a number of well-known languages are to be found as natural sublanguages.
]]></description>
<dc:subject>computer-science type-theory objects to-understand via:?</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2142359ec168/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:type-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:objects"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:?"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1705.00317">
    <title>[1705.00317] Non-polynomial Worst-Case Analysis of Recursive Programs</title>
    <dc:date>2017-05-07T12:24:33+00:00</dc:date>
    <link>https://arxiv.org/abs/1705.00317</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We study the problem of developing efficient approaches for proving worst-case bounds of non-deterministic recursive programs. Ranking functions are sound and complete for proving termination and worst-case bounds of nonrecursive programs. First, we apply ranking functions to recursion, resulting in measure functions. We show that measure functions provide a sound and complete approach to prove worst-case bounds of non-deterministic recursive programs. Our second contribution is the synthesis of measure functions in nonpolynomial forms. We show that non-polynomial measure functions with logarithm and exponentiation can be synthesized through abstraction of logarithmic or exponentiation terms, Farkas' Lemma, and Handelman's Theorem using linear programming. While previous methods obtain worst-case polynomial bounds, our approach can synthesize bounds of the form (nlogn) as well as (nr) where r is not an integer. We present experimental results to demonstrate that our approach can obtain efficiently worst-case bounds of classical recursive algorithms such as (i) Merge-Sort, the divide-and-conquer algorithm for the Closest-Pair problem, where we obtain (nlogn) worst-case bound, and (ii) Karatsuba's algorithm for polynomial multiplication and Strassen's algorithm for matrix multiplication, where we obtain (nr) bound such that r is not an integer and close to the best-known bounds for the respective algorithms.
]]></description>
<dc:subject>computer-science recursion algorithms to-understand benchmarking computational-complexity</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:ae949ae8063b/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:recursion"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:benchmarking"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1102.5683">
    <title>[1102.5683] Parallel addition in non-standard numeration systems</title>
    <dc:date>2017-04-29T13:02:37+00:00</dc:date>
    <link>https://arxiv.org/abs/1102.5683</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We consider numeration systems where digits are integers and the base is an algebraic number β such that |β|>1 and β satisfies a polynomial where one coefficient is dominant in a certain sense. For this class of bases β, we can find an alphabet of signed-digits on which addition is realizable by a parallel algorithm in constant time. This algorithm is a kind of generalization of the one of Avizienis. We also discuss the question of cardinality of the used alphabet, and we are able to modify our algorithm in order to work with a smaller alphabet. We then prove that β satisfies this dominance condition if and only if it has no conjugate of modulus 1. When the base β is the Golden Mean, we further refine the construction to obtain a parallel algorithm on the alphabet {−1,0,1}. This alphabet cannot be reduced any more.]]></description>
<dc:subject>algorithms computer-science number-theory rather-interesting parallel nudge-targets consider:rediscovery consider:performance-measures constraint-satisfaction to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:16fa0432be81/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:number-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:parallel"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:rediscovery"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:performance-measures"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:constraint-satisfaction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://programming-journal.org/purpose/">
    <title>Purpose and Operation</title>
    <dc:date>2017-04-17T12:06:23+00:00</dc:date>
    <link>http://programming-journal.org/purpose/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The Art, Science, and Engineering of Programming journal is a fully refereed, open access, free, electronic journal. It welcomes papers on the art of programming, broadly construed (see Call for Papers).

Papers are refereed in the traditional way, with two or more referees per paper. Copyright is retained by the authors. Full-text access to all papers is freely available. No registration or subscription is required. Authors of published papers may be invited to present their work in partnering conferences.

The journal is published by AOSA, a non-profit organization whose purpose is to facilitate the dissemination of scholarly works pertaining to programming.

Papers are prepared in LaTeX and submitted electronically as PDF files. On acceptance, authors are asked to provide all source files as specified in the Information for Authors.

Papers can be submitted at any time, but the journal reviews papers in batch, three or more times per year. The batch processing is designed to keep everyone involved (editors, reviewers and authors) on track, and to establish a strong sense of predictability for when specific activities are to happen. The goal is to have a fast turnaround of four months from start to end of each reviewing cycle.

The journal is divided into volumes, one per year, each with several issues. The issues correspond directly to the reviewing batches.

]]></description>
<dc:subject>via:geepawhill computer-science rather-interesting open-access journal academic-culture publishing arXiv</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:bf8bfb8b9947/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:geepawhill"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:open-access"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:journal"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:academic-culture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:publishing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:arXiv"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://search.arxiv.org:8081/paper.jsp?r=1501.06328&amp;qid=1490097869827ler_nCnN_397128995&amp;qs=%22recreational+math%22+OR+%22recreational+mathematics%22+OR+%22mathematical+recreations%22&amp;byDate=1">
    <title>[1501.06328] A weakly universal cellular automaton with 2 states on the tiling {11,3}</title>
    <dc:date>2017-03-23T23:50:41+00:00</dc:date>
    <link>http://search.arxiv.org:8081/paper.jsp?r=1501.06328&amp;qid=1490097869827ler_nCnN_397128995&amp;qs=%22recreational+math%22+OR+%22recreational+mathematics%22+OR+%22mathematical+recreations%22&amp;byDate=1</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper, we construct a weakly universal cellular automaton with two states only on the tiling {11,3}. The cellular automaton is rotation invariant and it is a true planar one.]]></description>
<dc:subject>cellular-automata computer-science universal-computation mathematical-recreations rather-interesting to-write-about visualization</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1406cdb98a29/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cellular-automata"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:universal-computation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:mathematical-recreations"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:visualization"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1701.03308">
    <title>[1701.03308] Sampling and Reconstruction Using Bloom Filters</title>
    <dc:date>2017-03-06T12:00:48+00:00</dc:date>
    <link>https://arxiv.org/abs/1701.03308</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper, we address the problem of sampling from a set and reconstructing a set stored as a Bloom filter. To the best of our knowledge our work is the first to address this question. We introduce a novel hierarchical data structure called BloomSampleTree that helps us design efficient algorithms to extract an almost uniform sample from the set stored in a Bloom filter and also allows us to reconstruct the set efficiently. In the case where the hash functions used in the Bloom filter implementation are partially invertible, in the sense that it is easy to calculate the set of elements that map to a particular hash value, we propose a second, more space-efficient method called HashInvert for the reconstruction. We study the properties of these two methods both analytically as well as experimentally. We provide bounds on run times for both methods and sample quality for the BloomSampleTree based algorithm, and show through an extensive experimental evaluation that our methods are efficient and effective.
]]></description>
<dc:subject>data-structures computer-science rather-interesting to-understand sampling seems-like-it-might-have-applications-in-GAs</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:a03ca46632e3/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-structures"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:sampling"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:seems-like-it-might-have-applications-in-GAs"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1701.07615">
    <title>[1701.07615] On the Design of Distributed Programming Models</title>
    <dc:date>2017-02-27T00:34:24+00:00</dc:date>
    <link>https://arxiv.org/abs/1701.07615</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Programming large-scale distributed applications requires new abstractions and models to be done well. We demonstrate that these models are possible. 
Following from both the FLP result and CAP theorem, we show that concurrent programming models are necessary, but not sufficient, in the construction of large-scale distributed systems because of the problem of failure and network partitions: languages need to be able to capture and encode the tradeoffs between consistency and availability. 
We present two programming models, Lasp and Austere, each of which makes a strong tradeoff with respects to the CAP theorem. These two models outline the bounds of distributed model design: strictly AP or strictly CP. We argue that all possible distributed programming models must come from this design space, and present one practical design that allows declarative specification of consistency tradeoffs, called Spry.
Su]]></description>
<dc:subject>distributed-processing programming-language computer-science rather-interesting concurrency cloud-computing</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1c01feced5e3/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:concurrency"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cloud-computing"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://github.com/engelberg/instaparse">
    <title>Engelberg/instaparse</title>
    <dc:date>2016-12-25T17:23:06+00:00</dc:date>
    <link>https://github.com/engelberg/instaparse</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[What if context-free grammars were as easy to use as regular expressions?

]]></description>
<dc:subject>parsing Klapaucius computer-science Clojure to-add-to-the-damned-language</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2cc8e83ac384/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:parsing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Klapaucius"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Clojure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-add-to-the-damned-language"/>
</rdf:Bag></taxo:topics>
</item>
</rdf:RDF>