The Unclear Impact

@juliank at uni, we’re developing something similar (in java, however), for SAT solving actually

in a previous version of the system, we were basically using journaling. that makes backtracking relatively easy, but jumping across different branches of the derivation tree (e.g., some heuristic tells you to abandon whatever you were doing, try something else, but if that doesn’t yield a solution quickly, go back to wherever you were in the search space) become inefficient, because you always have to first go back to the common ancestor, and then drill down again

currently, we’re experimenting with persistent data structures. HAMTs seem to work nicely as a big collection of labeled tuples (~graph edges). we’re following this paper: https://michael.steindorfer.name/publications/oopsla15.pdf but implemented it from scratch with our own optimizations

one particular optimization that seems useful is to have immutable and mutable tree nodes, and “check in” a new revision of a collection by copying each mutable node into a packed immutable one, which can handle batch updates more efficiently (immutable -> mutable when performing an update is just CoW)

of course, a persistent set of tuples is barely a graph, so we also have to maintain indexes for adjacency. the cool thing is that it’s very fast to determine the delta between two persistent data structures (just iterate over the two trees, skipping over immutable nodes that are referentially identical): when backtracking, you can calculate a delta (usually small), and update (mutable) indexes accordingly. we’re using https://github.com/viatra/org.eclipse.viatra to incrementally maintain indexes and graph queries, but https://github.com/vmware/differential-datalog would be another alternative

another idea would be to use another persistent data structure, like a ROMDD, radix tree, or even B-tree to store the indexes. but that might lead to pathological behavior on some inputs (that a randomly selected hash function in HAMT can avoid)

w.r.t. doing this in native code, I think you could get away with just releasing all mutable nodes when “checking in” and never releasing immutable ones (since “checking in” can control the number of stored versions, hopefully, there won’t be extremely many). otherwise, I’d try adding a refcount to mutable nodes, but I have no idea about its efficiency

optional author response period only to those papers which reached some level of support

does the lack of questions to respond to mean that

1. my paper was outright rejected with no support at all
2. the reviewers liked the paper, but had no questions
3. the chairs are late with sending out the questions

rationally, 3. is overwhelmingly likely, but my anxiety is mounting about 1.

making it clear that outright rejected papers will be notified early would have been nice

@szakib @trisschen @rysiek @cassidymcgurk given the stringent standards for certifying safety-critical systems (even in the automotive domain, where cost savings are otherwise foremost), this is not surprising: it’s highly unlikely one could devise a way to demonstrate the safety of an autopilot-like system with current system architectures

which, in a sane world, would mean deploying no such systems in production at all

@rysiek @cassidymcgurk what is weird is that how come disengaging not an admission that decisions made by the self-driving component up to that point have lead to an unsafe situtation? like we’d expect a human driver to drive defensively and not intentionally get into a dangerous situation

(test cases and even whole methods to generate such test cases have been proposed in academic literature as well as by some industry players, e.g., to make sure the system can reason about potential object obscured from its vision. so there’s at least an expectation for self-driving components to be programmed this way. nevertheless, tesla – and i presume other implementers – chose the easy way out and blame humans for the shortcomings of their systems)

whelp, i can’t exactly delete my github account right now (need it for uni stuff), but the pointless achievements they introduced is as good as a reason as any to at least set my profile completely private (and hide the achievements!)

@robby @signal9 the beatings will continue until the ethernet is plugged back

perl -0777 -i.bak -pe "s/\\n(import|export)([^']*)'\\.([^']*)';/\\n\\1\\2'.\\3.js';/gs" packages/*/src/**/*.ts{,x}

@icedquinn @pony @xerz @lanodan the ‘fun’ thing is that most of his campaign was built on scaremongering that the opposition candidate would get involved in the war and conscript people, and now the moment he’s in charge again he changes the ‘solid as granite’ that his cronies wrote to declare a state of emergency due to… checks notes the war.

at least they could have maintained some consistency to keep the story going, and drum up some other bs reason for the state of emergency

Maybe that’s a business, certified destruction of items claimed on expenses.

https://news.ycombinator.com/item?id=31482317

that’s horrific late-stage capitalism

looks like tomorrow i’ll have to get up at the time i went to bed today. fun times.

repositioning a paper and rewriting most of it 24 hours before the deadline, because the last of the measurement for the evaluation section change everything

@alexandra i read this at first as ‘XML and SQL email’, i.e., XML and SQL as a MIME message body part instead of plain text. i guess XML would be alright but a bit weird, SQL cursed, and combining them in XSQL (executed in the MUA and no less, i presume) truly cursed and definitely in the badly ruining territory