The Morning Paper

I can recommend Adrian Colyer‘s excellent The Morning Paper blog: https://blog.acolyer.org/

Now that The Morning Paper is shut down :( the only technical newsletter I follow these days is Micah Lerner's Systems Papers. https://newsletter.micahlerner.com/ https://blog.acolyer.org/

Yes, we subscribe to a few CS/eng blogs with our company Slack and use the threads for discussions. Sadly https://blog.acolyer.org/ doesn't update any more but that was one of the favourites.

The now discontinued "Morning Paper" has a great set of Archives. https://blog.acolyer.org

If you want to get into reading some CS papers, I can also recommend these sources: 1. The unfortunately defunct blog "The Morning Paper" that provides a short write-up/explainer of each paper. https://blog.acolyer.org 2. Will Larson's favorite CS papers. https://lethain.com/some-of-my-favorite-technical-papers/

The Morning paper: https://blog.acolyer.org/ Shocked this has not been mentioned yet. It's on hiatus "for now" but I hope this comes back, this was by far my favorite.

Here are a couple: - Papers We Love: https://paperswelove.org/ - The Morning Paper: https://blog.acolyer.org/ [edit: formatting]

I think this is a common reaction. We're built with fraud detection as social animals. People who talk as experts about areas their experience and accomplishments haven't aligned with always raise this. In this case, don't tell me how to learn when I question how much learning you've done. The opposite of this is Adrian Colyer's the morning paper [1], where I'd love to learn Adrian's process of ingesting so much technical information. As an aside, there are folks with expertise in certain areas that dip into a wide ranging set of topic. I try to remind myself of their expertise and discount heavily their opinion on other things: Elon Musk talking about anything not related to launching a car or space company. Elon's opinions about Covid-19 testing the latest example. Sam Atman talking about anything not related to VC investing. [1] - https://blog.acolyer.org/

I second this! Not math-focused, but you might love The Morning Paper: https://blog.acolyer.org/

Adrian Colyer's The Morning Paper[0] blog might be worth a look. (As he describes it, it's "a random walk through Computer Science research") If there are specific areas of interest, you can click "Tags" in the menu and get posts just about that area, e.g. you mentioned the Dynamo paper, so, you might be interested in developments in distributed systems. There's a Distributed Systems tag on the tag page[1] and, when you click it, you'll get this[2]. And it's a tag-cloud, so you can see by the size of the tags whether a given topic has a lot of entries or just a few. [0] https://blog.acolyer.org/ [1] https://blog.acolyer.org/tags/ [2] https://blog.acolyer.org/category/distributed-systems/

The menu of papers for the associated class, https://heather.miller.am/teaching/cs7680/, looks really rich. The class is from 2016. Looks like the book dates from 2016-2017. My first impression was that this was work in progress ... I'd be curious to see what from this set Adrian Colyer https://blog.acolyer.org/ has already digested. A perhaps interesting follow on would be to see which of these programming models are manifest today across the big cloud services .. or how they have advanced from this legacy work.

The Morning Paper by Adrian Colyer is fantastic. https://blog.acolyer.org/ https://blog.acolyer.org/tag/algorithms-and-data-structures/ I'll have to check out that YouTube channel you linked.

This is the journal referenced in the mailing list: https://onlinelibrary.wiley.com/journal/1097024x Seems the articles are free, if you don't want to pay the €6085 yearly instituational subscription. Other than Adrian's https://blog.acolyer.org/ what else is there worth watching that is closer to engineering than theory? I wish we still had DDJ or C/C++ User Journal, but today's periodicals are things like Rasperry Pi enthusiast or Monthly Minecraft Tips.

My favourites are: - https://blog.acolyer.org/ - http://sysadvent.blogspot.com/

Adrian Colyer's "The Morning Paper" is a similar one worth mentioning: https://blog.acolyer.org/

I'm surprised no one has mentioned "the morning paper" (https://blog.acolyer.org/) yet. Some papers are more advanced but a lot I found are definitely approachable. You can subscribe to the mailing list and get a new paper every day, along with the author's summary! That aside, I'm very impressed how he can keep up with this rhythm.

That would be nice, but it's my understanding that to really know what's going on in a scientific field, you need to read a bunch of papers in the field, not just one paper. It would be great to see more summaries of papers from trustworthy sources. For computer science there is The Morning Paper [1] but I don't know what there is for other fields. [1] https://blog.acolyer.org/

The Morning Paper (http://blog.acolyer.org) is the only source mentioned so far that I go out of my way to read. Highly recommended.

A couple things I try to do when reading research papers, inspired by these two amazing [b|v]logs. [1]https://blog.acolyer.org/ [2]https://www.youtube.com/user/keeroyz I try to paraphrase the paper into a Acolyer like 'morning paper' blog post on evernote while mentally I am directing a 'two minute paper' video on the paper :)

Interesting. I've been thinking about subscribing to "Stratechery" by Ben Thompson. Any recommendations for or against it? Currently subscribed to: - The Morning Paper (https://blog.acolyer.org/) - Benedict Evans (http://ben-evans.com/newsletter) - a16z (https://a16z.com/)

I like to follow The morning paper by Adrian Colyer. He writes a summary of an influential CS paper each day and sends it out on his e-mail list. https://blog.acolyer.org/

Adrian Colyer does something similar with his blog which I highly recommend: https://blog.acolyer.org/ Every weekday he posts a digestible summary of an influential paper, typically with a link to the paper itself.

This entire blog is great reading material for technical papers: https://blog.acolyer.org/

My approach is mostly to curate your news/social/stream feed to individual people that post the sort of things you like, and to slower-moving publications. Limit your follows on social media. Prefer blogs and RSS over Twitter-style social. And/or read journals/magazines/books and reviews of them instead. E.g. the old "The Morning Paper" blog by Adrian Colyer (https://blog.acolyer.org/) seems maybe up your alley? It's over now; dunno if what the new online versions of that are. For substantive programming stuff, these days I mostly read magazines and books, like CODE, Logic, and 2600. (IEEE Computer Society and ACMD have journals, but they're prety theoretical and academic; guessing that's not what you want here. I haven't found them very useful in my own programming work.) Sad to say, the current scene for this doesn't seem great. Old school Dr. Dobb's sounds like maybe what you want, but AFAICT there isn't really much like that any more? LWN and OSNews seem like modern online versions of stuff in that area, for system programmers at least. MIT Technology Review is also decent, but less about programming per se.

A few ideas: 1. Add "abstract" to your search query to surface papers. 2. Search for "... reading list". For example, Heidi Howard maintains https://github.com/heidihoward/distributed-consensus-reading-list 3. Read blogs like "The Morning Paper" (https://blog.acolyer.org) but skip fields that are outside your scope. You don't have time to follow more than one or two (or three) major fields. 4. Use Google Scholar to find the most cited papers, or to find papers that build on papers you think are good. 5. Keep an eye out for the conferences where these papers were presented. Then read the other papers that were also presented. 6. When you come across an amazing paper, read other papers by the same authors or supervisors. 7. If you're lucky you might also find good "survey" papers that cover and reference the state of the art. 8. Lecture notes from Stanford or MIT or another university can also be a great way to get a big picture of the evolution of techniques for a given data structure or problem. For example, these lecture notes are just brilliant for getting started with stuff around memory hierarchies: https://www.eidos.ic.i.u-tokyo.ac.jp/~tau/lecture/parallel_distributed… These are a few tricks that I find useful. What else?

>Reading white papers is a skill in its own, but as almost anything else, it can be learnt. I'm currently taking this great course [1] with Dave O'Hallaron (co-author of Computer Systems: A Programmer's Perspective / the 213 textbook [2]), in which we read and discuss papers about building scalable Internet services (list of papers available on the site). As part of the course we write critiques of each paper, including a quick summary and some notes about likes, dislikes, and questions for discussion. Taking the time to write this out explicitly really forces me to think more deeply about what each paper is about. And, the reading-group format with discussion with other people is helpful - hearing different perspectives and opinions really improves my understanding as well. I'd definitely recommend taking notes and trying to find a reading group for better understanding. As other comments have mentioned, Adrian Colyer's The Morning Paper [3] also has interesting reads. [1] http://course.ece.cmu.edu/~ece845/ [2] http://csapp.cs.cmu.edu/ [3] https://blog.acolyer.org/

My recommendations are not exactly what you ask but what I suspect you'll enjoy if you're asking this. (1) "Understanding Computation" by Tom Stuart. Not "fundamental" as a deep textbook, but very approachable for programmers intro into a big chunk of CS, explaining deep ideas about languages using rigorous working clean code (in Ruby, no prior knowledge needed). I especially loved the first few chapters about what it means to define a programming languange and various kinds of formal semantics. (2) Designing Data-Intensive Applications, Martin Kleppmann. This gives you a phenomenally good survey of concepts and practice of distributed systems. This is more software engineering than pure CS, but in my view you can't approach the field of distributed systems without blending both anyway. (3) POODR — Practical Object-Oriented Design, in Ruby, by Sandi Metz. This is 100% software engineering, where there is no single definition of "foundational", but many people who read this swear by it. It's remarkably thin but lucid distillation of ideas that were "in the air" but Sandi nailed them down. An important thesis is that good code is not an aesthetic judgement of how it _now_ looks, but objective question how easy it will be to _change in the future_. Not Ruby-specific at all, but it teaches the original Smalltalk "message-passing" view of OOP, that for people that only learnt statically-typed Java, C++ etc view of OOP is a fundamental idea they're missing on. Finally,…

Learn how to work with other people effectively (not just programmers, but PMs, finance types, legal experts, etc.) Took me like 15 years to be any good at this at all. Get exposure to customers. Try to get involved with decisions involving them. Many companies actively discourage engineers from having customer contact; this is bad, IMHO. Get exposure to the financial side of whatever industry you're in. You don't need to do official work, but definitely make sure you understand how your company makes money and what its risks are. (Do a start-up or two; this will give you a visceral feel for what money is worth assuming the places you work at are run well). Read a paper a week (e.g., something from usenix or the ACM, or whereever). Sites like The Morning Paper (https://blog.acolyer.org/) are pretty good; the thing is not to get caught in a rut. If you're doing IT work, get involved in dev work. If you're doing dev work, get involved in IT. These feed pretty heavily off of each other and operational background will boost your engineering skills as much as coding skills will help your IT work. Things I wish I'd studied harder, earlier: Statistics, practical aspects of databases and SQL, at-scale networking [didn't exist when I was a sprout], practical aspects of operating systems implementation (the stuff they didn't teach you in your course at school), maybe the first six months of an EE course . . . I could go on for quite a while. The good news is that there's no way…

Funnily enough, there is a paper on exactly what you're referring to from Microsoft Research called "Flexible Paxos": https://arxiv.org/pdf/1608.06696.pdf The gist of it is that there are realistically 2 quorums to be had: One for read/write to a cluster, and one for leader election. Assuming leader election is a relatively uncommon event (as it is in Paxos), you can require more quorum nodes for leader election while allowing less quorum nodes for quorum read/write. This means you get strong consistency with better performance. Distributed systems are one of my favorite things. I literally spent part of an evening with a beer reading a small handful of papers like this one. If you want an absolute treasure trove of similar works, visit the blog of Adrian Coyler: https://blog.acolyer.org/ He has a good writeup on the Flexible Paxos paper as well: https://blog.acolyer.org/2016/09/27/flexible-paxos-quorum-intersection…

> I literally spent part of an evening with a beer Just one? :) Consensus algorithms are _fascinating_! And +1 for https://blog.acolyer.org/ , I'll often read his blog over lunch. Another great paper is https://research.google.com/archive/paxos_made_live.html which talks about what it's like to realistically run Paxos. There's a ton of corner cases, engineering realities, and optimizations to be done to make Paxos work well in practice. Another good resource is the Raft GitHub page[1] which links to the paper, has an interactive visualization, and a plethora of talks by various people. Raft is the backbone of opensource, I'd be curious to hear from any Googlers in the know whether there's deficiencies in Raft that lead to continued use of Paxos, or if it's experience (and already battle-tested code) with Paxos that leads them to continue deploying Paxos-backed systems. [1] https://raft.github.io/