Ask HN: What was the best CS paper you read in 2017?
372 avinassh 10 hrs 98
news.ycombinator.com/item?id=16035402
sulam 8 hrs
I highly recommend people give this paper a read. I think it points the way to a radical redesign of fundamental parts of the system stack over the next 5-10 years. If you work in systems and you aren’t thinking about this stuff, you’re about to be lapped.
The Case for Learned Index Structures:
https://arxiv.org/pdf/1712.01208v1.pdf
chubot 7 hrs
I'm gonna throw some cold water on this and say this is not a new paradigm by any means.
https://www.sigarch.org/the-unreasonable-ineffectiveness-of-...
However, it's certainly possible that the time for this idea has come. Google is probably in the best position to apply it.
I will say that after having worked at Google for over a decade, some of it on data center performance, there are plenty of inefficiencies that have nothing to do with algorithms or code, but have more to do with very coarse-grained resource allocation. In other words, they are "boring management problems" rather than sexy CS problems.
I should also add that you're expanding the claims made in the paper, which appears to be a common mistake. If you look at the related work and citations, you'll see that it's mostly about B-Trees, bloom filters, and indices. But I have seen people generalizing this to "a revolution in systems research", which I don't believe is justified.
Indexed data structures are important but a revolution in them is not going to cause a revolution in all of systems. Off the top of my head, the general area of "scheduling" (in time and space) is probably more important and more potentially impactful.
sulam 6 hrs
Have you seen the results when they let a trained model manage Borg? The power reductions were immediate, non-trivial, and performance stayed the same. There's your scheduling result for you.
Look at it this way. As the paper points out, a Hashtable is just a heuristic that works fairly well in the worst case and reasonably well in the average case. No one would argue that you couldn't hand-roll an algorithm that is better for a specific, narrowly defined data set. This paper is demonstrating that you don't have to do it by hand, you can train a model automatically without the expected caveats like: size (doesn't have to be huge), latency (the model trains very quickly) or specialized hardware (they used bog-standard CPUs, not GPUs or TPUs).
This is obviously just my opinion, but I think it's pretty big. It's not big because of the paper itself, although that's amazing in isolation (they improved on hashtables!). As I said above, it points the way. They have a throw-away sentence about co-optimizing data layout along with lookup and not showing those result. My guess is that beats a hashtable in every way. More importantly, if a model can beat bloom filters, b-trees, and hashtables, you'd better hold onto your socks because most algorithms are just waiting to fall. To me this paper is Deep Blue vs Kasparov. We all know what comes next.
cinjon 2 hrs
Link to paper that cedes control of Borg?
sulam 1 hr
Blog post: https://deepmind.com/blog/deepmind-ai-reduces-google-data-ce...
Whitepaper: https://docs.google.com/a/google.com/viewer?url=www.google.c...
Eridrus 6 hrs
The article you link ends on a pretty weak claim, math didn't obsolete biologists and ML won't obsolete systems folks, but every time you write a heuristic you would probably get better results from a model.
robotresearcher 4 hrs
A heuristic is a model. A successful heuristic encodes knowledge of the distributions at hand. Heuristics are designed by people who had good insight into the data rather than learned directly from data, but they are models in the same sense.
yazr 6 hrs
Can you please give some examples of resource-mis-allocations ?!
AFAIK storage is not the system bottle it used to be. We always want more, but network and cores are relatively plentiful.
If we could magically (and safely) modify the software stack, which areas could give x2 or x3 improvements ?
sulam 3 hrs
Network latency right now is the biggest issue we have. If we could magically (using your term here!) get computational resources and data dramatically closer to end users, it would easily give 2 or 3x improvement. Doing this safely of course means consistently in this case, and being able to solve things like safe replication of large data sets. I dunno how to do it, but you asked and that's the biggest thing I can think of.
rgrieselhuber 6 hrs
Any resources you can recommend on the scheduling topic?
sulam 6 hrs
I can't find the exact paper, but you can find a lot after reading this article popularizing the topic:
https://www.theverge.com/2016/7/21/12246258/google-deepmind-...
The future is here. :)
eggie5 5 hrs
Interesting article I read from Zalando, which in the same vein as the Learned Indexes paper, takes a previously computationally expensive routine (Optimal Cart Pick) and learns it as an approximation to a complex function that, in the end, has faster run-time.
https://jobs.zalando.com/tech/blog/accelerating-warehouse-op...
sulam 5 hrs
Cool!
sova 5 hrs
Yo! This is what I'm talkin' about! Replace directories with self-consistent neural nwots [neural blackbox thingie of weights and activation vals]. It's cool, but for every convenience we take in the direction HD space we backpeddle in processing [meaning, although the dir structure could be super condensed this way with a learned index, this approach is less flexible to cold or not-cpu-related analysis]. It's very cool actually to consider the three branches of processing, hdd, and memcache ... You want to have a balance but in the ideal computer we do no calculation, and that is something worth mentioning.
Reading again of the abstract, allow me to add that it's an optimization beyond structures such as Btrees which are already not really decipherable datasets to the naked eyes. So any optimization in a space that's not designed to be human-legible can take whatever shape, and this is certainly a welcome achievement!
godelmachine 5 hrs
There was a time when people used to get PhD's for researching on index. This paper actually turns the table.
eggie5 5 hrs
nice pun
AlexTelon 7 hrs
A very interesting read indeed!
Besides HN how can one find great papers like this? How did you find out about it?
godelmachine 5 hrs
1) The Morning Paper - blog.acolyer.org - A new super interesting paper review everyday
2) This is my personal ritual. Every weekday I check out recent entries in "Hardware architectures" and "Emerging Technologies" section of arXiv.org Many other sections are gaining traction with me, like Database.
Hope this helps.
juanmirocks 5 hrs
Thank you for The Morning Paper
travmatt 4 hrs
You'd also like Fermat's Library
dekayed 6 hrs
I'd recommend taking a look at Papers We Love
https://github.com/papers-we-love/papers-we-love
rmk 14 mins
Loved the two-minute papers channel that I came across on this list. Thanks!
sulam 6 hrs
I found this paper after reading through Jeff Dean's talk at NIPS. I recommend that, too, obviously!
http://learningsys.org/nips17/assets/slides/dean-nips17.pdf
You can generally find a paper for each section.
CaHoop 7 hrs
I saw this paper on reddit.com/r/machinelearning - usually the more interesting ML papers are posted there.
Additionally, there is http://www.arxiv-sanity.com/ which sorts new machine learning papers by popularity.
allcentury 7 hrs
That was a good read, thanks for sharing this.
catnaroek 6 hrs
I've read that paper, and I wasn't particularly impressed. Is there any concrete evidence that learned indices scale to databases with complex schemata and a large transactional volume? Could learned indices be profitably used, say, in the database backend of an ERP system?
sulam 6 hrs
There are immediate applications to data warehousing. I hope that's obvious to you, but if not I'm happy to unpack that.
Whether or not it applies to online databases probably depends on several factors. The ones I can think of off the top of my head are the read/write ratio, the write rate in general, and obviously size of your data set (although the approach works at GB, not TB, so most can take advantage).
Here's a way, I, a systems engineer who doesn't design databases, could imagine using it immediately:
1) Do I have any indexed queries? If not, nothing to do here. 2) Does the data change rapidly? If so, nothing to do here. 3) Okay, now I'm in the zone of profitability:
1) investigate just letting the model do all the work. This is unlikely to be successful in many cases, but it's pretty easy to try.
2) investigate "model-assist", in this mode I let the model give me an answer and, if I don't like it, I use the B-tree. The model is fast enough that this is not a huge hit to my overall performance.
3) investigate "model-replace", in this mode I build my b-tree and do everything like normal. In the meantime I'm training my model. Once my model seems well-trained (I could hand it a randomized subset of queries and, once the accuracy and performance beats the b-tree I consider it well-trained), I switch to using it. As data changes I could potentially go back to the b-tree, update the model (literally throw it away and re-build) and do it again.
4) Investigate "co-opetition" -- make the b-tree a component of the model. If you read the paper, you see how they layer different models. A b-tree is just a particular kind of model that happens to be computationally expensive but has high accuracy. You could include it in the model graph and let it compete for queries like everything else.
Anyway, I'm speculating here, but it seems obvious this has immediate impact in one large space relating to databases (data warehousing) and potential impact in many of the rest.
catnaroek 4 hrs
There are immediate applications to data warehousing.
I am not too worried about data warehouses. Data warehouses can be fed by batch processes, which you can run, say, once every day or once every week. This leads to the design of algorithms that optimize aggregate measures of performance (e.g. amortized complexity, average complexity, throughput) rather than microscopic measures of performance (e.g. worst-case complexity, latency). Machine learning techniques have a track record of delivering good aggregate results.
However, online databases require optimal worst-case performance. The occasional massively slow operation is not okay - we'd rather every operation be a tiny bit slower instead.
Do I have any indexed queries? If not, nothing to do here.
Of course I do. Needless to say, complex schemata come with lots of indices that are necessary to speed up queries that pull data from 10-15 tables each.
Does the data change rapidly? If so, nothing to do here.
Of course the data changes rapidly. Crucially, an online transactional database's input comes from external parties (e.g., public-facing web servers) that cannot be considered trustworthy. Many machine learning techniques are vulnerable to so-called “adversarial examples”. Feeding adversarial examples to an ML-powered index could cause the database's performance to drop drastically in ways that are provably not possible with B-trees.
sulam 4 hrs
So, would you take a bet that this won't have been used in any self-evident way within the next 5 years?
Because I would take the other side of that bet. :)
catnaroek 4 hrs
I'm not in the business of predicting the future, since that is beyond my control. What other people do with learned indices is up to them.
I'm just stating my concerns.
oh-kumudo 5 hrs
Data warehousing is one obvious application: data is immutable; have a sort key. So NN as a builtin once index structure is perfect for such case. It is only a matter of time for commercial analytic DB to pick up this idea, I would presume.
catnaroek 3 hrs
You're right, data warehousing seems like a compelling use case for learned indices. I'm primarily worried about OLTP systems, though.
ky3 6 hrs
Leslie Lamport's 1978 "State the Problem Before Describing the Solution" [0]. On his web page the author adds that "The title says it all. This one-page note is as relevant today as when I wrote it. Replace "describing the solution" by "writing the program" and it becomes a practical recipe for improving software."
Herewith, the paper in full:
"After several years of writing papers in computer science, I discovered the basic expository rule embodied in the title of this note. As obvious as this rule may seem, there are fields in which it is seldom observed. (Computer networking is one example.) A typical paper in such a field is organized as follows:
(1) a brief informal statement of the problem;
(2) the solution;
(3) a statement and proof of the precise correctness properties satisfied by the solution.
In order to abide by the rule, the following organization should instead be used:
(1) a brief informal statement of the problem;
(2) the precise correctness conditions required of a solution;
(3) the solution;
(4) a proof that the solution satisfies the requisite conditions.
Although it may not be obvious at first glance, there is a profound difference between these two approaches. In the first, the precise correctness conditions can be (and usually are) stated in terms of the solution itself. Some results are proved about the solution, but it is often not clear exactly what problem is being solved. This makes the comparison of two different solutions rather difficult. With the second approach, one is forced to specify the precise problem to be solved independently of the method used in the solution. This can be a surprisingly difficult and enlightening task. It has on several occasions led me to discover that a "correct" algorithm did not really accomplish what I wanted it to. I strongly urge everyone to observe the rule.
(I am ignoring as unworthy of consideration the disturbingly large number of papers that never even attempt a precise statement of what problem they are solving.)"
[0] https://lamport.azurewebsites.net/pubs/state-the-problem.pdf
tybit 1 hr
Thanks for this, this one is very relevant to industry(or at least to mine). The amount of software designs and programs that don't actually fit the technical/business problems from the get go is astounding.
sktrdie 4 hrs
Statecharts: a visual formalism for complex systems: http://www.inf.ed.ac.uk/teaching/courses/seoc/2005_2006/reso...
Even though it's from 1986 it's enlightening how useful it is to think about reactive systems using statecharts - especially as a UI developer this seems to make total sense and was a ah-ha moment when I first read it a couple months ago.
wallflower 3 hrs
Elegant and simple. Thank you for sharing it even though it is over 30 years old.
Next time you happen to be at a store that has the rare, old fashioned-type automatic doors that swing out (not slide in/out), hurry out before your friends and stand on the pressure pad that is in the direction of the door swing out. No one will be able to exit.
This is a simple example of a state machine in the real world that I like to use to explain more complex state machines.
alecco 41 mins
A Seven-Dimensional Analysis of Hashing Methods and its Implications on Query Processing
http://www.vldb.org/pvldb/vol9/p96-richter.pdf
CalChris 7 hrs
seL4: Formal Verification of an OS Kernel (from 2009).
https://www.sigops.org/sosp/sosp09/papers/klein-sosp09.pdf
seL4 is about 9000 LOC. So this gives a good indication of what formal verification (Isabelle/HOL) is currently capable of. seL4 is also quite fast as a result of removing unnecessary checks.
https://sel4.systems/
seL4 is smaller than L4Ka::Pistachio and it's also capability based which L4 isn't. They could have called it L5 or seL5.
godelmachine 5 hrs
I want to learn formal verification on my own. Do you know of any resources? I got Rolf Dreshler's book on circuit verification, but I would like to master both hardware and software. Would you kindly provide with some pointers?
CalChris 5 hrs
It's a broad subject and I'm only interested in software verification. It's specialized enough that you should be reading papers and reading about systems. My favorite systems+papers are:
Coq: The world’s best macro assembler?
https://www.microsoft.com/en-us/research/publication/coq-wor...
Vale: Verifying High-Performance Cryptographic Assembly Code
https://project-everest.github.io/assets/vale2017.pdf
x86proved
https://x86proved.codeplex.com/
mcguire 4 hrs
Two schools:
-
Coq/dependent types. Check out Software Foundations by Benjamin Pierce, et. al. Everything's online. Also see Idris, which has a good book from Manning.
-
SMT-solver-based verification of existing languages. See SPARK/Ada (there's a good book but I can't remember the name presently) and the GNAT website. Also, Frama-C, although the documentation is more spotty. Then there's Rustan Leino's work on Dafny and Boogie. Oh, and Why3. And some work on verifying Java code that I haven't played with yet.
auggierose 2 hrs
Isabelle/HOL (the one sel4 was done in) appears in none of your two schools ...
This might be because it is the best combination of interactive theorem proving with automated methods that currently exists out there.
mcguire 3 hrs
Three, three schools:
- Model checking/high level formal specs. Lamport's TLA+, Alloy, possibly Z. There are some good TLA+ things online, I just couldn't get into it. (I feel bad.)
nickpsecurity 5 hrs
Note that this is formal verification of an imperative, C-based program manipulating low-level structures done years ago. I wouldnt say that represents what we're currently capable of in general case. For starters, a functional program or imperative without pointers (eg in SPARK) is much easier to verify than a C program. Plus, the seL4 organization recently reduced effort for filesystems down by a few multiples with a functional language.
Truth is the seL4 team set themselves up for a harder-than-usual job. For good reason but most folks (esp managed languages) won't see as much difficulty.
anilshanbhag 7 hrs
Chord: http://nms.lcs.mit.edu/papers/chord.pdf
I think this paper amazing because it solves a complex problem with a simple solution. How do you create a hash function that adjust to the varying number of underlying buckets ? Solution: hash to a circle.
pedrosorio 6 hrs
https://en.wikipedia.org/wiki/Consistent_hashing was actually introduced in 1997 by one of the authors of that paper.
nightcracker 7 hrs
If you like Chord then you'll also like Kademlia.
babangida 9 hrs
It's an old one, but this year I read The Emperor's Old Clothes by C.A.R. Hoare for the first time and it got me started in a Hoare rabbit hole, just a brilliant guy.
I read the annotated version on Fermat's Library - great source of interesting papers (http://fermatslibrary.com/s/the-emperors-old-clothes).
gnusouth 1 hr
I really liked Vlad Zamfir's papers on "correct-by-construction" consensus protocols. What I love about this work is that it unifies traditional BFT consensus with blockchain consensus to make something better than both! Really exciting!
Abstract CBC: https://github.com/ethereum/research/blob/master/papers/cbc-...
Casper the friendly GHOST: https://github.com/ethereum/research/blob/master/papers/Casp...
I found the Abstract CBC paper a little easier to understand, as it goes into more detail about the correct-by-construction process.
johnsonjo 6 hrs
I found Knuth’s “Dancing Links” paper [1] very well written and a somewhat easy read (I had to reread certain parts a couple times). I had to write a sudoku solver for one of my classes and I read that dancing links and algorithm x was one way to do it [2]. I then read some things around the internet to apply dancing links to sudoku solving [3] [4]. If you read the Wikipedia entry on exact cover problems there is a section on sudoku as an exact cover problem [5] this is one thing necessary to understand in order to implement a sudoku solver with algorithm x and dancing links.
Knuth even talks about dancing links in his new 2017 Christmas Tree Lecture [6] specifically here at 4:28 [7]. Basically he uses dancing links to solve for certain n in the problem he sets up in that lecture.
[1] https://arxiv.org/abs/cs/0011047
[2] https://en.wikipedia.org/wiki/Sudoku_solving_algorithms#Exac...
[3] http://garethrees.org/2007/06/10/zendoku-generation/
[4] https://www.ocf.berkeley.edu/~jchu/publicportal/sudoku/sudok...
[5] https://en.wikipedia.org/wiki/Exact_cover#Sudoku
[6] https://www.youtube.com/watch?v=BxQw4CdxLr8
[7] https://youtu.be/BxQw4CdxLr8?t=4m28s
svat 5 hrs
You may like to know that Knuth's fascicle 5C of The Art of Computer Programming Volume 4 is going to be entirely about Dancing Links. He's still working on it, but the “incomplete draft” is available at the (hidden) link https://cs.stanford.edu/~knuth/fasc5c.ps.gz — check it out if you're interested; it's already 130 pages of fun.
johnsonjo 3 hrs
Wow, this really is good I started it and skimmed the rest of it the first 34 pages are explanations and algorithms of dancing links and the rest of the 130 pages is all exercises and answers to those exercises. Truly awesome, thanks again for the link.
johnsonjo 5 hrs
I think he mentioned that it would be in his new book, but I had no idea there would be over 100 pages of dancing links. That is sweet! I’d love to take a look at it, so I could get a better grasp of how it applies to other problems.
mcguire 3 hrs
Knuth is, almost universally, a joy to read.
JelteF 9 hrs
The raft consensus algorithm article [1] and the follow up that modifies it slightly with some changes that are useful when implementing it [2]. Both are written very clearly and very focused on actually using the algorithm in practice. Problems that arise when implementing it are discussed and solutions are proposed as well.
[1] https://raft.github.io/raft.pdf
[2] http://openlife.cc/system/files/4-modifications-for-Raft-con...
indescions_2017 8 hrs
Bringing The Web Up To Speed With WebAssembly
https://github.com/WebAssembly/spec/blob/master/papers/pldi2...
trojanh 6 hrs
That link seems to broken. Here the original link https://github.com/WebAssembly/spec/raw/master/papers/pldi20...
Definitely a good read.
godelmachine 5 hrs
Adrian Colyer's review on WebAssembly was very helpful.
vletrmx 7 hrs
Some Were Meant for C: The Endurance of an Unmanageable Language
https://www.cl.cam.ac.uk/~srk31/research/papers/kell17some-p...
icodemuch 8 hrs
The bitcoin white paper (https://bitcoin.org/bitcoin.pdf)
toomim 7 hrs
Yeehaw! This was the best paper I read in 2012, and then again in 2013, 2015, 2016, and 2017.
DiThi 1 hr
What paper was the best in 2014?
grajaganDev 9 hrs
* What Developers Want and Need from Program Analysis - An Empirical Study
-
Weird machines, exploitability, and provable unexploitability
-
What You Corrupt Is Not What You Crash: Challenges in Fuzzing Embedded Devices
mafribe 8 hrs
* What Developers ...: http://ieeexplore.ieee.org/document/7582770 (Sorry, no open version seems to be available)
spenrose 7 hrs
Openly accessible "What Developers Want ..."
https://www.microsoft.com/en-us/research/wp-content/uploads/...
obtained by pasting the title into scholar.google.com
cynicaldevil 5 hrs
"Reflections on Trusting Trust": https://www.ece.cmu.edu/~ganger/712.fall02/papers/p761-thomp...
rozim 4 hrs
I probably enjoyed 'Mastering the game of Go with deep neural networks and tree search' the most and especially appreciated the 'Methods' section where they go into a good amount of detail about their implementation.
https://storage.googleapis.com/deepmind-media/alphago/AlphaG...
posnet 4 hrs
A General-Purpose Counting Filter: Making Every Bit Count
A better alternative to bloom filters and they provide a well written implementation as well https://github.com/splatlab/cqf
https://www3.cs.stonybrook.edu/~ppandey/files/p775-pandey.pd...
akditer 6 hrs
What Makes A Great Software Engineer?
https://faculty.washington.edu/ajko/papers/Li2015GreatEngine...
Metaphors We Compute By Code is a story that explains how to solve a particular problem
http://delivery.acm.org/10.1145/3130000/3127495/p40-videla.p...
leecarraher 2 hrs
Dynamic Routing Between Capsules the long awaited paper from Geoffrey Hinton (although Sara Sabour is principal author, Hinton has been hinting at this for a while now) on an alternative to back-propagation https://arxiv.org/abs/1710.09829
beefman 4 hrs
Programming languages
Slepak et al - An Array-Oriented Language with Static Rank Polymorphism [1]
Distributed systems
Kiayias et al - A Provably Secure Proof-of-Stake Blockchain Protocol [2]
Cognitive computing
Boahen - A Neuromorph's Prospectus [3]
Machine learning
Silver et al - Mastering Chess and Shogi [4]
1 http://www.ccs.neu.edu/home/shivers/papers/rank-polymorphism...
2 https://eprint.iacr.org/2016/889.pdf
3 https://pdfs.semanticscholar.org/3767/1e53c9949fa08d9dc150ad...
4 https://arxiv.org/pdf/1712.01815.pdf
kzrdude 7 hrs
The most useful paper I read this year was Tidy Data (Wickham) http://vita.had.co.nz/papers/tidy-data.html
AlexCoventry 5 hrs
Emergence of Invariance and Disentangling in Deep Representations
https://arxiv.org/abs/1706.01350
"we show that in a deep neural network invariance to nuisance factors is equivalent to information minimality of the learned representation, and that stacking layers and injecting noise during training naturally bias the network towards learning invariant representations. We then show that, in order to avoid memorization, we need to limit the quantity of information stored in the weights, which leads to a novel usage of the Information Bottleneck Lagrangian on the weights as a learning criterion"
superzamp 4 hrs
Not originally a CS paper, but this one describes a distributed algorithm medieval merchants used to simplify their debts graph: http://eh.net/eha/wp-content/uploads/2013/11/boerner.pdf
I highly recommend it to anyone interested in CS, history & finance.
wk2jkhkjdfglsl 3 hrs
Dullien, Thomas F. "Weird machines, exploitability, and provable unexploitability." IEEE Transactions on Emerging Topics in Computing (2017). http://ieeexplore.ieee.org/abstract/document/8226852/
vjdhama 9 hrs
Lifeguard : SWIM-ing with Situational Awareness
https://arxiv.org/pdf/1707.00788.pdf
cygned 3 hrs
“The Evolution of LISP”, Steele/Gabriel (1993).
PDF: https://www.csee.umbc.edu//courses/331/resources/papers/Evol...
80 pages, very well written and interesting.
bra-ket 9 hrs
"Memcomputing NP-complete problems in polynomial time using polynomial resources and collective states" http://advances.sciencemag.org/content/1/6/e1500031.full
pelario 8 hrs
Could you tell us a bit about the reñevance of this work?
DannyBee 7 hrs
They claim they can actually build things that compute np-complete problems in polynomial time for real.
"We show an experimental demonstration of an actual memcomputing architecture that solves the NP-complete version of the subset sum problem in only one step and is composed of a number of memprocessors that scales linearly with the size of the problem. We have fabricated this architecture using standard microelectronic technology so that it can be easily realized in any laboratory setting"
This is traditionally what people look to quantum computing to solve, but that seems much farther off in practice that the technology described here, at least, as described.
TL;DR Memcomputing has been shown to have the same power as non-deterministic turing machines. They claim to have made some real ones with promising results. It looks like it's getting commercialized over at http://memcpu.com/.
I'm just summarizing the papers/data, not commenting on it for real, it could all just be snake oil
godelmachine 5 hrs
They have pretty much exaggerated their capability. I implore any curious HN reader to check out Scott Aaronson's review of their work & how he debunks it.
chadcmulligan 3 hrs
thanks, link for the impatient https://www.scottaaronson.com/blog/?p=2212
saycheese 8 hrs
Does anyone have any suggestions on finding CS papers worth reading beyond those papers listed here?
chubot 6 hrs
Follow the citations of papers you liked. Note the authors and read their other publications.
Look at other papers in the same conference. Watch conference videos on YouTube.
Skim at first, and then reread papers that pop back into your mind.
tnecniv 7 hrs
In my experience, you read a lot of papers that sound interesting and then some of them turn out to be good.
azhenley 7 hrs
What topics are you interested in? Following the top ACM and IEEE conferences in that area is a good start!
For example, I'm interested in human-computer interaction so I read CHI and UIST papers each year, and for software engineering I read ICSE and FSE.
toomim 7 hrs
Ah, if only CHI and UIST had good papers these days. :/
azhenley 7 hrs
Hey, I had a CHI paper this year! I think it publishes many great papers each year.
toomim 4 hrs
Welcome to the echo chamber.
In my experience, the only people who think CHI publishes great papers are the people publishing at CHI.
(Disclosure: I've published at CHI a few times myself. I'm done with it.)
azhenley 2 hrs
A company recruited me at CHI for an internship/collaboration and implemented portions of my research into their product, so it isn't a complete echo chamber.
mcguire 3 hrs
I remember LISA and USENIX.
whistlerbrk 4 hrs
See PapersWeLove
saycheese 52 mins
http://paperswelove.org
azhenley 7 hrs
"Foraging Goes Mobile: Foraging While Debugging on Mobile Devices" (ftp://ftp.cs.orst.edu/pub/burnett/vlhcc17-foraging-mobile.pdf)
"Toward Principles for the Design of Navigation Affordances in Code Editors: An Empirical Investigation" (http://dl.acm.org/authorize?N37917)
"The Patchworks Code Editor: Toward Faster Navigation with Less Code Arranging and Fewer Navigation Mistakes" (http://dl.acm.org/authorize?N84177)
moretai 29 mins
May I ask why people read cs papers to gauge if I should be reading them?
lwh 7 hrs
This miserable blog post http://www.sicpers.info/2017/12/computings-fundamental-princ...
mcguire 3 hrs
T-t-t-taligent?
My second real job out of college was with IBM's Taligent Project Office (where I independently invented mobile IP routing); I bailed as the wheels were coming if the IBM/Apple partnership.
nickpsecurity 9 hrs
I read a lot of good ones but I'll answer what was most important rather than best. We're seeing a revival of formal methods ranging from lightweight (TLA+) to heavy. Two problems are in my sight: lack of framework plus consistent, empirical data for evaluating how suitable a given method is for a specific project or company; many who would use lightweight or practical methods will quit because someone convinced them to start with heavy ones. The paper below is a start on the former:
https://www.scch.at/de/rse-news/passende-formale-methon?file...
I think that was a great start on an evalution criteria because its comparisons match what I read in the various experience reports. ASM's and TLA+ coming in the lead on usability but B method on code generation. It will also help to note what projects have been completed or reusable libraries available in each. A person building verified compilers for functional languages might want to learn Isabelle/HOL due to CakeML, doing a new TLS extension learn F* due to miTLS, type-safe assembly learn Coq due to CoqASM, and so on.
For the other issue, I made a proposal on HN first and then on Lobste.rs about avoiding people quitting early from finding formal methods too overwhelming or useless. I proposed having a default intro or lure that matched the goals of different people to tools with a warning of some's difficulty. It got some interesting responses (below) I'll turn into a mini-essay with links eventually.
https://lobste.rs/s/n7v658/your_thoughts_on_this_advice_thos...