The major genetic risk factor for severe Covid-19 is inherited from Neandertals - <AUTHOR> https://www.biorxiv.org/content/10.1101/2020.07.03.186296v1 <comment><USER2> If you have 23andme, the exact allele is not on the chip. However, a different allele is strongly associated with the region:

[https://you.23andme.com/tools/data/?query=rs10490770&filter_...](https://you.23andme.com/tools/data/?query=rs10490770&filter_by_platforms=true)

The major A/A variant is listed as T/T on 23andme. If you have a result other than "T/T", you're likely to be in the high-risk group.

refs: [https://www.snpedia.com/index.php/Rs11385942](https://www.snpedia.com/index.php/Rs11385942) [not on 23andme] [https://www.snpedia.com/index.php/Rs10490770](https://www.snpedia.com/index.php/Rs10490770)

<comment><USER3> That 23andme link doesn't work for me, it says no genes or markers found for rs10490770.

<comment><AUTHOR> Try this : [https://www.ncbi.nlm.nih.gov/projects/SNP/snp_ref.cgi?do_not...](https://www.ncbi.nlm.nih.gov/projects/SNP/snp_ref.cgi?do_not_redirect&rs=rs10490770)

This breaks down the population frequencies. Of note: the HAPMAP AA frequencies: Gujarati Indians in Houston Texas : 38% , African ancestry in Southwest USA: 4%. It is absent in Chinese, Japanese and sub-saharan Africans.

</comment></comment></comment><comment><AUTHOR> Svante Pääbo , one of the preprint authors, is the head of the Max Planck Institute for Evolutionary Anthropology. [https://en.wikipedia.org/wiki/Svante_P%C3%A4%C3%A4bo](https://en.wikipedia.org/wiki/Svante_P%C3%A4%C3%A4bo) . He is known for his work in assembling the Neanderthal and Denisovan genomes.

Of particular note in this paper, the genetic variants in the genomic locus discussed are found in 30% of South Asian populations: India and Bangladesh. The highest frequency occurs in Bangladesh, where more than half the population (63%) carries at least one copy of the Neandertal risk variant and 13% is homozygous for the variant. The risk variant is 8% frequency in Europe.

The hg19 location of Genetic variants in LD (r2>0.99) with rs11385942 in Eurasian populations can be viewed here at the UCSC genome browser: [https://genome.ucsc.edu/cgi- bin/hgTracks?db=hg19&position=ch...](https://genome.ucsc.edu/cgi- bin/hgTracks?db=hg19&position=chr3%3A45871908%2D45909024)

The genome wide association study that points out this area of the genome is here : [https://www.nejm.org/doi/full/10.1056/NEJMoa2020283](https://www.nejm.org/doi/full/10.1056/NEJMoa2020283) . At this "locus 3p21.31, the association signal spanned the genes SLC6A20, LZTFL1, CCR9, FYCO1, CXCR6 and XCR1."

Three of the genes, XCR1 CXCR6 CCR9, are involved with chemokine receptor activity and G-protein coupled chemoattractant receptor activity.

<comment><USER4> Also only ~4% in the US, and virtually absent in Africa.

</comment></comment><comment><USER5> "Here, we show that the risk is conferred by a genomic segment of ~50 kb that is inherited from Neandertals and occurs at a frequency of ~30% in south Asia and ~8% in Europe."

Hmmm...thus far, the mortality per capita from Covid-19 has been much higher in Europe, especially western Europe, than in south Asia. Not saying that couldn't change, but the weekly mortality peaks in western Europe were literally an order of magnitude higher than for Bangladesh, India, or Pakistan. So either this finding is flawed in some way, or (perhaps more likely) even the biggest genetic risk factor for severe Covid-19 is not that big of a factor, and what's going on is mostly not genetic.

<comment><USER6> Or maybe the stats used for the data in European countries are flawed...or there is less testing in the latter countries....

<comment><USER7> You don't need testing, just accurate body counts. You can see COVID hit Europe as a spike in excess deaths, even if you weren't testing. If there were currently a mortality spike in Bangladesh _even higher than Europe 's_, it would not go unnoticed. Disappearing bodies is not that easy.

<comment><USER8> I mean.. China's official numbers are around 84k infected.. and much less dead than that. So...

<comment><USER9> The "count the bodies" technique is meant for situations where the country can't test for COVID, either because it was too early or they don't have the infrastructure. That technique won't work on countries just willing to lie about it.

</comment></comment></comment></comment></comment><comment><USER10> Standard disclaimer that this is a preprint that has not been peer reviewed.

</comment><comment><USER11> I do not have any particular comment on this gene or the topic of COVID-19, but I have a related question for the experts out there.

Let's say I were to send off to Dante labs and get my entire genome sequenced. Given emerging research like this where someone says "we have identified this specific gene that does so-and-so," does the average geek have any hope of being able to determine if they have a copy of that gene? Or does that type of interpretation require the effort of a trained expert?

How close are we to receiving a personalized genetic vulnerability feed? I'm sure the hypochondriacs out there would sign up in a heartbeat.

</comment><comment><USER12> [Sars-Cov-2][Outcome risk] rs10490770 (Caucasisn only)

Risk: AG, GG (~15.5% of population?)

Safe: AA (~84.5% of population?)

\--- SO, if 23andme says its T/T and its actually A/A(as herf said), than 84.5% of the population would have T/T via 23andme. I am confused then. If I have T/T through 23andme, am I at higher risk when ~85% of the population has the same thing?

</comment><comment><USER13> But how can this be, given that African-Americans, with far less Neanderthal ancestry than European-Americans, are dying of COVID-19 at a much higher rate in the US?

<comment><USER14> Given that there's a strong correlation between race and poverty in the US (via racism) and a strong correlation between poverty and infection rate which, it seems to mean poverty is a greater indicator than genetics. After all the genetic factor only comes into play after exposure, while poverty increases the likelyhood of exposure

<comment><AUTHOR> Other factors may be obesity ( [https://www.minorityhealth.hhs.gov/omh/browse.aspx?lvl=4&lvl...](https://www.minorityhealth.hhs.gov/omh/browse.aspx?lvl=4&lvlid=25) ) , diabetes ( [https://www.minorityhealth.hhs.gov/omh/browse.aspx?lvl=4&lvl...](https://www.minorityhealth.hhs.gov/omh/browse.aspx?lvl=4&lvlid=18)) and Vitamin D deficiency ( [http://www.cooperinstitute.org/2019/09/24/african- americans-...](http://www.cooperinstitute.org/2019/09/24/african-americans-at- greatest-risk-of-vitamin-d-deficiency) ).

<comment><USER15> What underlies all of that is the strength of the immune system, which will be low for many diets and lifestyles.

</comment></comment></comment></comment><comment><USER16> So in my 23andme it shows me as having the T/T genotype of this marker. Does that mean I do or do not have the at risk marker?

<comment><USER12> I think you're good. From what I've read, the high risk is C. T/T is modern human. C is neanderthal. So C/C - youre 3 times more likely to get sick. C/T youre 1.5times more likely to get sick.

Reference: [https://www.gnxp.com/WordPress/2020/07/04/using-23andme- ance...](https://www.gnxp.com/WordPress/2020/07/04/using-23andme-ancestry- family-tree-dna-to-identify-risk-allele-for-respiratory-failure-with- covid-19/comment-page-1/)

=== If this is wrong, someone correct me, but T/T results from 23andme seem to be 84.5% of the population (caucasion people), so YOU SHOULD BE FINE.</comment></comment>


Barliman: Prototype of a smart text editor - <AUTHOR> https://github.com/webyrd/Barliman <comment><USER2>
        > given a fully or mostly-specified definition of some function foo, Barliman will attempt to prove that a partially-specified test is consistent with, or inconsistent with, the definition of foo.

I feel like this is what GHC (the Haskell compiler) does for me. Where the "test", in this case, is the type definition. And there is no room for error here.

So it's possible that this idea makes more sense for languages without a strong type system. In any case, trying to complete a partial function definition without looking at the native types of the language means you miss a lot of information, especially in the case of Haskell, where the types tell you so much, if not everything, you need to know about a function.

<comment><USER3> Thank you for your comments!

I agree that type-directed synthesis would be very helpful. One of the inspirations for Barliman is the type-and-example-directed program synthesis by Peter-Michael Osera and Steve Zdancewic:

[http://www.cis.upenn.edu/~stevez/papers/OZ15.pdf](http://www.cis.upenn.edu/~stevez/papers/OZ15.pdf)

I want to experiment with a typed version of Scheme (a mini-ML with s-expressions) to see how much types would improve synthesis. In previous work with Michael Ballantyne, Michael showed that adding types could significantly improve the synthesis capability of the relational interpreter used by Barliman.

The miniKanren constraint logic system used by Barliman can be use to write type checkers and type inferencers that can perform type habitation, similar in spirit to the Djinn system mentioned by Cybiote. This is a topic Oleg Kiselyov and Dan Friedman have explored, for example. I'm very interested in improving our ability to write more sophisticated type inferencers in miniKanren, and in using the inferencer to guide synthesis.

Part of the motivation for Barliman is to explore what can be done for dynamically typed languages. Perhaps something like soft typing or gradual typing would be useful in this context.

Another idea I want to explore is using high-level properties, as in property- based testing, or even software contracts, to help guide synthesis.

I should mention that Greg Rosenblatt has improved Barliman's synthesis abilities recently, by specializing the underlying relational interpreter, using techniques similar to those in the Mercury compiler. I need to update the documentation to show the improved synthesis, which still needs work in order to be useful.

I'm also working with Rob Zinkov and Evan Donahue on using stochastic search to improve miniKanren's synthesis ability.

I'm very much open to collaboration on Barliman, synthesis, relational interpreters/type inferencers, constraint logic programming, etc.

<comment><USER2> I guess I don't quite understand the root purpose of program synthesis. It's my impression, as a programmer, that the difficult task is defining ones program logic without ambiguity. If this is indeed the case, then program synthesis already exists in the form of Coq, but it doesn't mean we've made programming easier, it means we've created a tool that reveals _all_ possible failure points of a program, forcing us to consider all possible outcomes. It makes for a provably un-crashable program, but we pay for it in the time it takes to create the specification/implementation (which at this point have converged into one). If I can write a specification in a language that some tool can transform into a source code implementation (which can then be compiled and executed), then I wouldn't call that tool a "program synthesizer" but rather a "compiler" (and the specification language would then be a programming language).

<comment><USER3> Good questions!

> It's my impression, as a programmer, that the difficult task is defining > ones program logic without ambiguity.

Certainly the unambiguous specification of a program's behavior is a difficult task! Barliman's approach is to allow for the behavior of a function to be _partially specified_. That is, the specification of behavior is _ambiguous_ , since the examples can only specify the intended behavior over a small number of inputs/expected outputs. Many other synthesis tools allow for ambiguous specification of behavior, and use heuristics such as parsimony (smallest program is assumed to be the correct choice) to pick one of infinitely many programs consistent with the partial specification.

The idea for Barliman is to make the writing/editing of the code interact with synthesis-by-example, in order to give the programmer continuous feedback on whether the current code is consistent with the tests, and hopefully to make a reasonable guess at any missing code. As the programmer fills in the code for a function, the search space shrinks. Still, there may be infinitely many definitions that satisfy the partial specification, so Barliman sometimes guesses a goofy definition!

I want to explore adding high-level properties, contracts, optional types, etc., to Barliman, to make it possible to specify the desired behavior in more detail. However, I want to make all of these specifications _optional_ , to maintain the flexibility of a language like Scheme. I think this is still an under-explored area in program synthesis, especially given how much code is written in JavaScript, Python, Ruby, etc.

> If I can write a specification in a language that some tool can transform > into a source code implementation (which can then be compiled and executed), > then I wouldn't call that tool a "program synthesizer" but rather a > "compiler" (and the specification language would then be a programming > language).

It is true that if you completely specify/prove correct your program in Coq (for example), you can extract a running programming from that specification. This is an interesting and powerful technique, and is in many ways similar to a compiler, as you point out.

However, I don't think of this approach as program synthesis. In program synthesis I might give a _non-constructive_ specification of a program's behavior, and ask the computer to find such a program. For example, I could completely specify what it means for a number `n` to be the square root of another number `m` without giving an algorithm to find `n`. If I know of such an algorithm, I may be able to prove it correct in Coq, and extract running code from Coq. However, I can't expect that Coq will _find_ the algorithm for me. To me this is the difference between proving code correct and performing synthesis.

However, the division is somewhat murky--for example, some forms of synthesis can be used to prove correctness of the program. For example, a well-known example in miniKanren (the system Barliman uses for synthesis) is to generate a quine directly from the mathematical definition of a quine. A quine in Scheme is some expression `q` that evaluates to itself. In a relational Scheme interpreter implemented in miniKanren, we can generate quines by running the query:

(run n (q) (evalo q q))

Where `n` is the number of quines you would like to generate, `evalo` is the name of the relational Scheme interpreter, and `run` is miniKanren's interface operator. One of the quines generated is:

((lambda (_.0) (list _.0 (list 'quote _.0))) '(lambda (_.0) (list _.0 (list 'quote _.0))))

where `_.0` is a legal Scheme identifier. This expression is alpha-equivalent to the most famous Scheme quine ([https://www.nyx.net/~gthompso/quine.htm](https://www.nyx.net/~gthompso/quine.htm)).

In the case of quine generation, we are _proving_ that the generated program is a quine by synthesizing it from its definition. (Assuming that both miniKanren and the relational Scheme interpreter are correct, of course!) We have also synthesized fixpoint combinators from their definitions in a similar fashion. Note that this approach is different from, but complimentary to, the synthesis-from-example approach used by Barliman.

If the quines example interests you, you might look at our paper and code from the 2012 Scheme Workshop:

William E. Byrd, Eric Holk, and Daniel P. Friedman. miniKanren, Live and Untagged: Quine Generation via Relational Interpreters (Programming Pearl). Proceedings of the 2012 Workshop on Scheme and Functional Programming, Copenhagen, Denmark, 2012.

[http://webyrd.net/quines/quines.pdf](http://webyrd.net/quines/quines.pdf)

[https://github.com/webyrd/2012-scheme-workshop-quines- paper-...](https://github.com/webyrd/2012-scheme-workshop-quines-paper-code)

</comment></comment></comment></comment><comment><USER4> Byrd has been working on miniKanren for over a decade. He showed before how you can easily program miniKanren to produce quines through search.

The question I would have is that producing specifications for trivial tasks may be just as hard if not harder than programming the same tasks. Often the program is the specification.

<comment><USER5> Agreed, because the problem domain/system dynamics needs to be encoded into Scheme before synthesis can be useful for high level specs. If this kind of programming style takes off, it could possibly be useful for communities to supply "starter templates" for common patterns and system behaviors that they manually reason about all the time.

<comment><USER3> Yes, using templates for common patterns could be helpful. Or even using machine learning over existing code bases to infer such templates.

Similar to the use of templates is Matt Might's suggestion of using Barliman for code repair--given an _almost correct_ definition of a function, and both passing and failing tests, try to massage the code to make it pass all the tests. I think templates could be useful here.

There are many approaches to synthesis, and Barliman's implementation is still very naive. Experiments by Michael Ballantyne and Greg Rosenblatt have shown that some synthesis tasks in miniKanren (used internally by Barliman) can be speed up by factors of thousands to millions (by restricting the grammar and using a type system, or by performing program specialization on the relational Scheme interpreter, as in the Mercury compiler). Alas, since synthesis is inherently exponential in terms of program size, a speedup of a million means that you can synthesize only a slightly larger expression. And the techniques Michael and Greg have used don't work for all problems, and can reduce the generality of the programs that can be synthesized.

Still, given how many synthesis techinques, tricks, and optimizations that we _haven 't_ tried, I'm optimistic that Barliman's synthesis can be improved enough to be practical for at least some uses. What those uses are, I'm not sure.

</comment></comment></comment><comment><USER3> Thank you for the interest in Barliman!

I'll try to answer all of the questions this afternoon.

Also, I'm very much open to collaboration on Barliman, synthesis, relational interpreters/type inferencers, constraint logic programming, etc.! :)

<comment><AUTHOR> I have some questions.

a.) What do you think about the current/future state of logic programming?

b.) Do you think that logic programming can at some point be 'mainstream'? If so, what steps need to happen for this to occur.

c.) Is there a particular area of problems that would really benefit from being solved with logic programming? E.g. I was surprised to learn that Windows used to have an embedded prolog interpreter for network configuration and I realized that there must be more areas that could benefit from using logic programming.

d.) Are there some areas where logic programming should never be used?

e.) What is the thing/insight that sparked your interest in this particular research area?

<comment><USER3> Thanks for the post, the pull requests, and the questions!

I find that it's impossible to give enough context when answering high-level questions such as these, so some of my answers will probably seem more provocative or critical than I intend. Please ask me for more details/context for any answers that seem especially ridiculous/stupid. I'm _not_ promising, though, that the answers _aren 't_ ridiculous/stupid! :)

I'll answer these questions in reverse order.

> e.) What is the thing/insight that sparked your interest in this particular > research area?

I had zero interest in logic programming until I saw two programs.

The first was a relational type inferencer written in the original Kanren language, capable of type inhabitation--that is, of synthesizing expressions of a given type. Dan Friedman showed me this program in his B521 graduate programming languages course at Indiana University in Fall 2003. He and Oleg Kiselyov had been playing with these relational type inferencers; this made me want to write an interpreter for Scheme in the same fashion, to generate Scheme expressions that evaluate to a given value. It took us a long time to figure out how to do this is a semi-reasonable way! Our first interesting relational interpreter is described in this paper:

William E. Byrd, Eric Holk, and Daniel P. Friedman. miniKanren, Live and Untagged: Quine Generation via Relational Interpreters (Programming Pearl). Proceedings of the 2012 Workshop on Scheme and Functional Programming, Copenhagen, Denmark, 2012.

[http://webyrd.net/quines/quines.pdf](http://webyrd.net/quines/quines.pdf)

[https://github.com/webyrd/2012-scheme-workshop-quines- paper-...](https://github.com/webyrd/2012-scheme-workshop-quines-paper-code)

This interpreter the single most interesting and enjoyable program I've worked on, and is the basis for Barliman's synthesis. I intend to keep improving this program for the rest of my life.

The second program was the relational arithmetic system that Oleg Kiselyov created, and which appears in chapters 7 and 8 of 'The Reasoned Schemer'. This is the system that convinced me that non-trivial programs can be expressed as true relations, allowing logic variables to be placed in arbitrary positions, and that such programs could be efficient enough to produce interesting answers in practice. A Prolog version of the arithmetic system can be found in this paper:

Oleg Kiselyov, William E. Byrd, Daniel P. Friedman and Chung-chieh Shan. Pure, declarative, and constructive arithmetic relations (declarative pearl). In Proceedings of the 9th International Symposium on Functional and Logic Programming, ed. Jacques Garrigue and Manuel Hermenegildo, pp. 64-80. LNCS vol. 4989, Springer, 2008.

[http://webyrd.net/arithm/arithm.pdf](http://webyrd.net/arithm/arithm.pdf)

> d.) Are there some areas where logic programming should never be used?

"Never" is a very serious word! :) I don't think we know enough about _any_ form of programming to use words like "always" and "never." I agree with Gerry Sussman and Alan Kay that we really don't have any idea of how to program. That is doubly true for the kinds of relational programs we're exploring with miniKanren.

Also, I don't really do logic programming, as it's commonly understood. (As in Prolog programming, for example.) I'm interested in writing non-trivial programs as _relations_ , in which variables representing unknown sub-terms can be placed anywhere, within any argument. Relational programming overlaps with traditional logic programming in many ways, but really has a different feel, different goals, and requires different techniques, and different features from the underlying language.

In the short term I would say that relational programming should be used for everything, and nothing. 'Nothing,' since it is so difficult to write efficient relational programs, or even to write queries that are guaranteed to terminate. 'Everything,' since writing programs as relations is often shocking, infuriating, and delightful, all at the same time.

For example, when we were working on the relational Scheme interpreter, we had no idea that it could generate quines from their mathematical definition, until Stu Halloway pointed this out to me and Dan Friedman at Clojure/conj. Talk about a bolt from the blue! And later Michael Ballantyne showed that we could treat the Scheme definition of `append` as a relation by running it inside the relational Scheme interpreter, instead of writing a special `appendo` relation directly in miniKanren. This is the technique used by Barliman! I didn't realize either of these insights, even after many years of writing relational interpreters. I love writing these short programs that can surprise its creator in such deep ways, even after many years!

<comment><USER3> > c.) Is there a particular area of problems that would really benefit from > being solved with logic programming? E.g. I was surprised to learn that > Windows used to have an embedded prolog interpreter for network > configuration and I realized that there must be more areas that could > benefit from using logic programming.

I suppose the standard answer is: rule-based systems that have to perform some type of logical inference. For example, UBS bank apparently wrote a rule-based system in core.logic (David Nolen's Clojure library, originally based on miniKanren, but which now has many extensions). My understanding is that the UBS system was some sort of expert system, determining when certain financial operations should occur. This is a very Prology application.

Like I said above, I'm much more interested in relational programming than in logic programming. I'm not sure which problems benefit most from relational programming, which is one reason I created the Barliman prototype. Nehal Patel thinks that the generality/efficiency tradeoff inherent in the relational interpreter approach to program synthesis makes it most useful for extremely difficult or extremely general problems that cannot be readily expressed using other techniques. This would be similar in spirit to techniques like Markov Chain Monte Carlo--a very general, but potentially slow, technique that should never be be used (here's the "never" word!) if a faster, more specific technique is applicable, but which can be used to express all manner of messy computation.

> b.) Do you think that logic programming can at some point be 'mainstream'? > If so, what steps need to happen for this to occur.

In the 1980s logic programming _was_ mainstream, at least in Japan! ([https://en.wikipedia.org/wiki/Fifth_generation_computer](https://en.wikipedia.org/wiki/Fifth_generation_computer)) LISP, Common Lisp, and Lisp machines, and all that, was also semi-mainstream, in that companies and organizations were willing to spend real money on custom hardware and programmers to develop expert systems.

LISP and Prolog were closely connected to good ol' fashioned symbolic AI. During (that season of) the AI winter, the bottom fell out from under LISP and Prolog.

LISP hasn't _really_ become mainstream, although Clojure is fairly popular. But functional programming, and especially _ideas_ from functional programming, has become much more mainstream in the past 10 years. Garbage collection, closures, and even (semi-)hygienic macros are now standard features--or at least standard extensions--in am increasing number of popular or semi-popular languages.

There are at least some uses of logic programming that have started to become popular again. Datalog is being used for static analysis, LogicBlox is selling Datalog-based products to major corporations, Clojure's Datomic is (or contains) a Datalog, and I know of at least one startup writing a custom Datalog. So at least Datalog, which is closely related to Prolog, seems to be gaining in popularity.

What hasn't taken off again is a full, general purpose logic programming language, like Prolog. Maybe functional programming has to become more firmly entrenched in industry before general purpose logic programming can become popular, since logic programming is even higher-level, more abstract, and further from the hardware than functional programming. Trying to understand how the search and constraint solving works, seems much more difficult for most programmers than understanding how Lisp's `cons` works, for example. Understanding monads seems closer in difficulty to understanding basic logic programming--the proliferation of tutorials on the basic ideas of miniKanren and core.logic reminds me a little of the multitude of monad tutorials.

There is also the applicability and performance issue. There is increasing interest in using functional programming, or at least functional techniques, in AAA video games, and there have been a few success stories. Still, using Haskell to write Call of Duty 17 doesn't seem feasible right now. Similarly, it's not clear how to write such a game using a general-purpose logic language. I think what's clear, though, is that _parts_ of these games can be a good match for functional or logic languages or DSLs.

> a.) What do you think about the current/future state of logic programming?

I'm disappointed by the extent to which Prolog is still dominant in the logic programming community, especially for research. I have nothing against Prolog. Having a mono-culture, though, stifles lots of ideas. (Thought experiment-- imagine what the state of programming languages research would be in all research was done in...FORTRAN, LISP, Haskell, or any other single language, no matter how great that language is.)

Curry, Mercury, Mozart/Oz, and miniKanren, of course, each have a different take on logic programming than does Prolog, and the logic programming community has never been entirely a mono-culture. But compared to functional programing, for example, there are far fewer logic programming languages that are at all popular, or that are used in research or industry.

I suspect that the dominance of Prolog is one reason that logic programming isn't currently more popular. Haskell, Scheme, Common Lisp, Scala, Clojure, F#, OCaml, Racket, etc., are active enough, and have vibrant enough communities, that someone interested in functional programming can pick from a wide variety of languages, with different philosophies, syntax, type systems, tooling, etc. In the logic programming world it's still either Prolog...or some essentially marginal language (in terms of popularity, not quality!) with a tiny community.

I do think that many people are interested in the _ideas_ of logic programming, especially now that functional programming ideas have become mainstream, having infected even Java and C++. People are starting to look for the next higher level of abstraction after traditional functional programming, be it dependent types, proof assistants, logic programming, or whatever. And I find the interest in Datalog, and the interest in miniKanren, promising.

Unless some language/killer-application combination appears out of the blue (think Ruby/Rails), I suspect that for the foreseeable future it will be the _ideas_ of logic programming, and perhaps a few logic programming DSLs, that influence the broader programming community, and only for the early adopters.

Using multiple DSLs to express different paradigms within the same program seems entirely reasonable to me. This is a very Lispy/Schemely/Rackety notion. There is lots of interest in DSLs these days, and more languages are supporting macro systems, even hygienic macro systems (at least for limited notions of "hygienic"). I wouldn't be surprised if logic programming ideas slip into programmers' toolkits through DSLs like miniKanren or embedded Prologs. Something like an O'Reilly book on using logic programming DSLs to solve common problems would go a long way towards making these techniques more widely known.

As far as the future of relational programming, as opposed to logic programming, I think we haven't even scratched the surface of what is possible. I'm inspired by Alan Kay's saying that "the best way to predict the future is to invent it." :)

<comment><AUTHOR> If you'd prefer to take this discussion to email we can.

> Thanks for the post, the pull requests, and the questions!

You are very welcome, lol. There might be more coming as time permits. I'll keep an eye out on the progress.

> I'm not promising, though, that the answers aren't ridiculous/stupid! :-)

I've always felt like people are too afraid about not sharing their ridiculous ideas anyway :-).

> I suppose the standard answer is: rule-based systems that have to perform > some type of logical inference.

I think that my question was a bit too ambiguous. I think that I meant like an area where logic programming isn't currently commonly used (to me, the network configuration tool seems very out of place for example) but it would be a match made in heaven. I'm aware of expert systems :-).

> In the 1980s logic programming was mainstream, at least in Japan!

I'm actually aware but for some reason it's not mainstream now.

> What hasn't taken off again is a full, general purpose logic programming > language, like Prolog.

That's what I was asking about. E.g. would it make sense to e.g. write an OS in a logic/relational language? What sort of CPU support would be required to make this a serious effort? I think what I'm getting at is that I feel like e.g. Prolog isn't truly general purpose. I get that it's turing complete but large portion of programs are much slower in prolog (as you say yourself). Is this something that's "inherent" to logic languages (like even if HW support were better, will it always (i know i know, no absolutes but you get the gist) be MUCH slower or could it be just slightly slower)?

Like I realize that they are slower because they are fundamentally doing a search but I'm wondering if e.g (and I'm really just trowing ideas on the wall here) it's possible to leverage type systems and hw support to considerably reduce the runtime search space and do most of it on compile time. Are you familiar with liquid types (you mention dependent types, so I'm guessing yes?)?

In your work, you seem to be gravitating towards dynamically typed languages. Wouldn't a lot of work be easier in like Haskell or some other type language? I'm sure you have good reasons for not having switched and I'm interested in hearing those. Why are Lisps better for your work?

> "Never" is a very serious word! :-) I don't think we know enough about any > form of programming to use words like "always" and "never."

I was actually thinking about wording it slightly less absolutely but I was interested if there were any problems where logic programming would be a bad idea no matter what so it would be basically "never".

> Unless some language/killer-application combination appears out of the blue > (think Ruby/Rails),

I think that's part of what I was asking. What would be a "killer" app for logic programming? Are there any problems out there that aren't currently being solved with logical programming but would really benefit from them?

Btw can you recommend some literature on the intersection of logic/constraint/relational programming and music? I've ordered this book [https://amazon.com/dp/1848212887/](https://amazon.com/dp/1848212887/)

I'll check out the links you posted. I'm actually working full-time on this music composition app (logic/relational programming isn't the main contribution of the application but I'm just trying to see if there's some low hanging fruit I could do easily and blow minds). If you have any sort of input into that I'm be interested. I saw on your CV that you supervised some undergrad research in this area so I'm guessing that you might not be unfamiliar with that intersection.

I did see like the top google links when I searched for the combination of those keywords (e.g. [https://vimeo.com/55677313](https://vimeo.com/55677313)) so I think I'm interested in some sort of meta analysis.

<comment><USER3> > If you'd prefer to take this discussion to email we can.

Sure. I'll take a crack at these followup questions first, though!

> I think that my question was a bit too ambiguous. I think that I meant like > an area where logic programming isn't currently commonly used (to me, the > network configuration tool seems very out of place for example) but it would > be a match made in heaven. I'm aware of expert systems :-).

It doesn't surprise me to see Prolog in a configuration system, since configuration is a standard use of expert systems--for example, Xcon ([https://en.wikipedia.org/wiki/Xcon](https://en.wikipedia.org/wiki/Xcon)). Getting a manager at Microsoft to allow the use of Prolog is the surprising thing to me! :)

> That's what I was asking about. E.g. would it make sense to e.g. write an OS > in a logic/relational language? What sort of CPU support would be required > to make this a serious effort? I think what I'm getting at is that I feel > like e.g. Prolog isn't truly general purpose. I get that it's turing > complete but large portion of programs are much slower in prolog (as you say > yourself). Is this something that's "inherent" to logic languages (like even > if HW support were better, will it always (i know i know, no absolutes but > you get the gist) be MUCH slower or could it be just slightly slower)?

You can play all sorts of "extra-logical" tricks in Prolog to improve performance, at the cost of giving up declarativeness. Still, Prolog is not the language I'd reach for first when writing system software, as you point out.

Have you looked at Mercury? Mercury is a logic programming language that borrows heavily from Haskell. One cool thing about Mercury is that you define high-level relations, specifying types and other annotations for each relation. The Mercury compiler then compiles the high-level declarative relations into lower level, more efficient functional definitions. One high- level relation might be compiled to many functions, which are dispatched to at run-time based on the groundness of the arguments passed to the relation. Mercury is specifically designed for system programming, and also has support for parallelism.

I should point out that Mercury relations aren't _really_ full relations, like they are in miniKanren. Mercury compiles away unifications for efficiency, which means that Mercury can't handle more sophisticated uses of logic variables. For example, the quine-generating query would be impossible to specify in Mercury. But the resulting code is much more efficient.

Greg Rosenblatt has applied a few of the Mercury compiler techniques to the relational interpreter used by Barliman, which has sped up some synthesis queries by orders of magnitude. He suspects there are more gains to be made from borrowing Mercury optimizations.

> Like I realize that they are slower because they are fundamentally doing a > search but I'm wondering if e.g (and I'm really just trowing ideas on the > wall here) it's possible to leverage type systems and hw support to > considerably reduce the runtime search space and do most of it on compile > time. Are you familiar with liquid types (you mention dependent types, so > I'm guessing yes?)?

I'm not sure what you mean by hardware support, exactly. Are you talking about using accelerators like GPUs or FPGAs? If so, as far as I can tell miniKanren doesn't map well onto these accelerators, although the Intel Phi might be a decent match.

I suspect that running synthesis tasks on a beefy server, or even on a cluster, would result in a significant improvement to performance. Static analysis and compiler optimizations would probably make a much bigger difference, though.

I'm slightly familiar with liquid types. There may be ways for dependent types to prune parts of the search space statically, although I'm not sure. I'd like to explore combining miniKanren and Idris, to see where that leads.

> In your work, you seem to be gravitating towards dynamically typed > languages. Wouldn't a lot of work be easier in like Haskell or some other > type language? I'm sure you have good reasons for not having switched and > I'm interested in hearing those. Why are Lisps better for your work?

I like Scheme because it has very powerful meta-programming capabilities, it is easy to write meta-circular interpreters, it is trivial to write DSLs (without having to write parsers or whatever), and the abstract syntax and concrete syntax are essentially the same. Being able to just call 'read' to parse an expression, and being able to redefine built-in binding forms, for example, can be extremely handy.

Haskell is a language chock full of interesting ideas. I don't love it, though. The syntax, lack of macros, all the extensions in GHC, etc., make for a language that is powerful but complex. I like languages that are powerful but small, containing only a few concepts. miniKanren itself only has three core operators; the relational interpreter uses an extended version of miniKanren with six operators, but we hope to get that down to five.

In short, Scheme fits my programming style better. I'm not averse to using other languages, though. And miniKanren has been ported to dozens of host languages, including multiple Haskell implementations.

As far as the types making things easier, I'm not sure this is true. Many ML and Haskell programmers have looked at miniKanren and said, "this would be so much better with types!" After playing around with the implementation for a while, they usually say, "taking advantage of the types without losing the flavor of miniKanren is much harder than I thought." As far as I can tell, the only _interesting_ embedding of miniKanren in a typed language is Dmitry Boulytchev's OCanren ([https://github.com/dboulytchev/OCanren](https://github.com/dboulytchev/OCanren)). Dmitry had to hack the OCaml type system at a low (and potentially unsafe) level to make the embedding possible. I would be interested in exploring OCanren for writing relational interpreters. I'm not exactly sure what it would buy us, though.

There are lots of interesting connections between dependent types and logic programming. I'd like to explore combining Idris and ideas from miniKanren, for example. To me, combining Idris and miniKanren seems more interesting and promising than combining Haskell and miniKanren, which has been done many times without apparent benefit.

Now, in contrast to the host language used for the embedding of miniKanren, implementing a typed language in the relational interpreter _definitely_ makes synthesis easier. In other words, implementing a relational interpreter for an ML-like language, using miniKanren embedded in Scheme, is probably far better for synthesis than implementing a relational interpreter for Scheme, using miniKanren embedded in Haskell.

I definitely plan to investigate relational interpreters for typed languages (Michael Ballantyne has already done some work in this area, and showed great improvements in synthesis). I'm also open to exploring miniKanren's embedded in typed languages. This seems like a much trickier problem than you might think, though. OCanren looks like a promising start, and I look forward to playing with it more.

> I was actually thinking about wording it slightly less absolutely but I was > interested if there were any problems where logic programming would be a bad > idea no matter what so it would be basically "never".

I think this largely depends on what you consider "logic programming". Mercury seems applicable to systems programming problems that aren't an ideal match for traditional Prolog, for example. And Curry allows functional programming and logic programming to be blended in interesting ways that blur the lines between the paradigms.

There are also approaches like Answer Set Programming, and even Answer Set Programming Modulo Theories, that use powerful solvers to solve problems that would be hopelessly inefficient with naive Prolog (or miniKanren) search.

So I'll stick with my original answer, and say it's far too soon to tell. :) We do need new langauges and approaches, though!

> I think that's part of what I was asking. What would be a "killer" app for > logic programming? Are there any problems out there that aren't currently > being solved with logical programming but would really benefit from them?

Such a tiny percentage of programmers have even _heard_ about Answer Set Programming; it's possible there are killer apps for ASP laying around, just waiting for someone to connect the ideas.

I suspect killer apps will be found for probabilistic logic programming, as the languages and implementations improve, and as more people become comfortable with probabilistic programming.

And, of course, I'm hoping program synthesis using logic programming will be a killer app! :)

> Btw can you recommend some literature on the intersection of > logic/constraint/relational programming and music? I've ordered this book > [https://amazon.com/dp/1848212887/](https://amazon.com/dp/1848212887/) > > I'll check out the links you posted. I'm actually working full-time on this > music composition app (logic/relational programming isn't the main > contribution of the application but I'm just trying to see if there's some > low hanging fruit I could do easily and blow minds). If you have any sort of > input into that I'm be interested. I saw on your CV that you supervised some > undergrad research in this area so I'm guessing that you might not be > unfamiliar with that intersection. > I did see like the top google links > when I searched for the combination of those keywords (e.g. > [https://vimeo.com/55677313](https://vimeo.com/55677313)) so I think I'm > interested in some sort of meta analysis.

I'd be happy to talk to you about this in more depth, maybe via hangouts. I think it depends very much on what you want to do. For example, synthesis of music that pleases humans is still an open problem. But other problems seem more tractable.

</comment></comment></comment></comment></comment></comment><comment><USER6> It would have been nice to see some more information on the way this works. I'm not clear exactly what is being searched- some set of built-in functions that are combined in the hopes of finding one that makes tests pass? A space of function components?

It's cool but I'd like to know what it does exactly. Maybe the explanation is spread around examples, but skimming through them I couldn't find it.

<comment><USER3> Barliman's synthesis is based on the "relational interpreter" approach described in this 2012 Scheme Workshop paper:

William E. Byrd, Eric Holk, and Daniel P. Friedman. miniKanren, Live and Untagged: Quine Generation via Relational Interpreters (Programming Pearl). Proceedings of the 2012 Workshop on Scheme and Functional Programming, Copenhagen, Denmark, 2012.

[http://webyrd.net/quines/quines.pdf](http://webyrd.net/quines/quines.pdf)

[https://github.com/webyrd/2012-scheme-workshop-quines- paper-...](https://github.com/webyrd/2012-scheme-workshop-quines-paper-code)

The basic idea is to write an interpreter as a _relation_ in a constraint logic programming language (miniKanren, in this case). Since the interpreter is a relation, there is no real distinction between "input" arguments and "output" values. More generally, arguments to the relational interpreter can be partially-instantiated terms that contain logic variables representing unknown subexpressions.

Since the interpreter for "miniScheme" is fully relational, running the interpreter "forwards" to generate a value from a given expressions, or running the interpreter "backwards" to generate an expression that evaluates to a given value, are essentially the same operation. The only difference is where the logic variables are placed in the query to the relational interpreter.

But the approach is more general than just running the interpreter forward or backward. Logic variables can be used in _both_ the expression to be evaluated, and in the expected value. This is how we can generate quines (expressions that evaluate to themselves) in miniKanren directly from the mathematical definition of a quine, for example. The query

(run N (q) (evalo q q))

will produce N quines, including a quine that is alpha-equivalent to the canonical Scheme quine

((lambda (x) (list x (list (quote quote) x))) (quote (lambda (x) (list x (list (quote quote) x)))))

This example shows some of the generality of the relational interpreter approach---program inversion applied to a Scheme interpreter would not be able to generate quines.

The search is done over all possible terms in "miniScheme," a Turing-complete subset of Scheme that supports higher-order variadic functions, recursion, lists and pairs, lexical scoping/shadowing, etc., and that has been extended with pattern-matching.

Does that help?

</comment></comment><comment><USER7> > I'm starting with cocoa since I'm developing on a Mac

Does anyone here have an idea of how easy or difficult it would be to build this on Linux? The GNUStep website says they framework closely follows Apple's Cocoa. And yet, I am not familiar with any sizeable Mac app getting ported to Linux via GNUStep.

<comment><USER3> Good question!

I'm not sure how easy it would be to compile Barliman under GNUStep. I would like to have a version of Barliman that runs on different platforms, perhaps using JavaScript/Clojurescript/whatever.

The GUI part of Barliman isn't that sophisticated. I think the trickier part is managing the Chez Scheme processes that are being launched/killed in the background. If there are N tests/examples, Barliman will launch N+2 processes of Chez Scheme, in parallel, each one running a miniKanren query. Killing these processes and starting new ones reliably is critical.

I'm not sure how easy it would be to launch and manage Chez Scheme instances using Node.js, for example.

If you are interested in compiling Barliman under GNUStep, I'd be happy to help. I'd be willing to try to rewrite parts of the code that aren't supported by GNUStep, for example. I assume GNUStep supports Swift? If not, we would have to rewrite Barliman in Objective-C, which would be fine by me.

I should mention that I've been thinking about separating the GUI completely from process management, to make it easier to run synthesis processes on remote machines, such as a beefy EC2 X1 instance. At that point, hopefully it would be quite simple to write a new front end for Barliman.

Do you have any recommendations for cross-platform GUIs that can also launch and manage parallel processes well?

Thanks!

<comment><USER7> > If you are interested in compiling Barliman under GNUStep, I'd be happy to > help.

Thank you for being open to it, but since I'm not a Schemer (yet) so I don't see myself using it, beyond playing with it for fun.

> I assume GNUStep supports Swift?

From the best I could gather[1], this appears to be work-in-progress. GNUStep's Objective-C API is apparently at OSX-10.6 level.

> recommendations for cross-platform GUIs that can also launch and manage > parallel processes well

QT comes to mind. Their QProcess class seems pretty neat to me.

[1] [https://www.reddit.com/r/swift/comments/49r82f/swiftgnustep_...](https://www.reddit.com/r/swift/comments/49r82f/swiftgnustep_support_on_linux/)

[2] [https://doc.qt.io/qt-5/qprocess.html](https://doc.qt.io/qt-5/qprocess.html)

</comment></comment></comment><comment><USER8> Does anyone generate tests automatically?

I've been looking for something related to this. Whenever I design unit test cases, I write out the common edge cases, let's say: valid input, invalid input (wrong data type), invalid input (too long), etc, then translate them into tests. I might write them in a way that the tests are the combination of various dimensions of input, one per variable. For example, try input1=['a', 'aaa', None] x input2=[-1, 0, 1, None] for each combination knowing which I expect to pass and fail.

Often the tests are similar (write one, duplicate, slightly change the logic), and I've always felt like there has to be some kind of test generation framework out there to do this, though I haven't heard of anyone actually using one.

<comment><USER9> Immediately QuickCheck comes to mind ([https://hackage.haskell.org/package/QuickCheck](https://hackage.haskell.org/package/QuickCheck)).

Folks have written (possibly less powerful) implementations in Python ([https://github.com/HypothesisWorks/hypothesis- python](https://github.com/HypothesisWorks/hypothesis-python)), Javascript ([https://github.com/jsverify/jsverify](https://github.com/jsverify/jsverify)), etc.

FWIW I've found them fragile and lacking for my use cases - but I bet fuzzing style testing tools could be pretty valuable in certain cases.

</comment></comment><comment><USER10> Sort of a nitpick, but green always makes me think "tests passing", whereas you've got it meaning "incomplete expression" (or something along those lines, since you point out that it's not the same as syntax errors).

<comment><USER3> Thanks for the comment!

I agree! The newer interface includes an "Illegal sexpression" messages, but still uses the sickly green color. I need to fix this--any suggestions? :)

<comment><USER11> A wavy red underline is the established default for inline error reporting at this point, for better or worse. That's probably the best thing to use unless you're determined to make advances in graphical user interface layout, which — I hope it isn't rude to point out — doesn't seem to be a goal of Barliman, from looking at the screenshots.

If you're going to highlight errors with an error background color, I suggest blue, which contrasts better with green than red or yellow can, especially if you're somewhat red-green colorblind, like I am. Alternatively, maybe you could reduce the contrast on the whole pane except for the error, as if you were trying to scam the programmer into supplying their email address to continue reading an article.

<comment><USER3> Good point! I like the idea of using a wavy red line. Thanks!

Yeah the user interface is pretty budget right now. :) I've been teaching myself Swift and Cocoa programming, and still have lots to learn. And I've been concentrating more on the "under the hood" pieces of Barliman. But I do want to explore new interface and GUI ideas.

I suspect the interface will change completely in the future. Tom Gilray, for example, has suggested using just a regular editor window, which Barliman would parse to find the definitions, examples, optional type annotations, etc. This would be closer in spirit to the XCode interface.

One interface question is how to best specify the semantics for the language under interpretation (for example, "miniScheme"). Currently the semantics are specified by writing a "relational" interpreter in miniKanren. This is pretty low level, though. I'd like to have a much high-level specification language that looks closer to the math for operational semantics.

</comment></comment></comment></comment><comment><USER12> It wasn't clear to me how the "best guess" works. Did I miss it?

Indeed, if program synthesis can be done for even slightly non-trivial tasks (find in list, etc) that would be a huge boon for StackOverflow answer bots.

<comment><USER3> I gave a short, semi-technical explanation of how Barliman performs synthesis in my answer to `YeGoblynQueenne`. I'm not sure if that description answers your question, though.

I agree that relatively modest synthesis could be useful; exploring modest synthesis is why I made Barliman, although I hope Barliman's synthesis can be made less modest! :)

</comment></comment><comment><USER13> This is ambitious. I don't really believe it will be rally useful one day, but who know, maybe it is the primitive form of a program which will replace programmers in the future.

<comment><USER3> Thanks!

Yes, Barliman is ambitious. Both the synthesis capabilities and the interface will need to improve before Barliman might be useful for practicing programmers.

One question Barliman is trying to explore is whether relatively modest synthesis abilities might be useful for some tasks. If the last 10% of a function could be synthesized, for example, how useful would that be? Perhaps a better question is, "for which tasks, if any, would modest synthesis be useful"?

I don't know the answer to this question.

A tool like Barliman _might_ be useful in an educational setting. However, this seems a bit like the calcular/Wolfram Alpha debate in teaching math. If Barliman becomes good enough to synthesize many simple Scheme definitions from examples, would that take away too many learning opportunities from students? I suppose it would teach students to think of example tests, and perhaps even properties, types, or contracts, for the functions they are defining. But it does seem that the better synthesis works, the less useful Barliman might be in a teaching setting.

One suggestion from Matt Matt is to use Barliman for code _repair_. For example, say I define a function `foo`, along with several tests that `foo` passes. Later I find that the definition of `foo` is incorrect, and come up with several more tests that fail using the current definition. Barliman could have an "auto repair" button that attempts to synthesize a correct definition of `foo` from both the tests and the "almost correct" existing definition. I have several ideas of how this might be done. For autorepair (and other synthesis tasks) it would be helpful to extend Barliman to run synthesis tasks remotely--for example, on an EC2 X1 instance with dozens of hardware threads.

For more advanced synthesis tasks, I think we'll need a more sophisticated search. I was very impressed with Alpha Go's performance over a giant search space that historically has been considered the domain of human experts, a task that reminds me greatly of synthesis. I'm working with Rob Zinkov and Evan Donahue on using stochastic search/Markov Chain Monte Carlo/etc. to try to allow miniKanren's search to explore more promising areas in the search space. One inspiring piece of related work is this 2013 ASPLOS paper by Schkufza, Sharma, and Aiken on Stochastic Superoptimization:

[http://theory.stanford.edu/~aiken/publications/papers/asplos...](http://theory.stanford.edu/~aiken/publications/papers/asplos13.pdf)

I don't see Barliman or other synthesis tools replacing programmers any time soon, but in 10 or 15 years I hope our tools will be assisting us with useful synthesis tasks.

<comment><USER3> * Matt Matt -> Matt Might. Getting a little sleepy! ;)

</comment></comment></comment><comment><USER6> It's nice to see a logic programming subject on HN's first page- the second in two days.

<comment><USER3> Cool! What was the other post?

<comment><USER6> This one:

[https://news.ycombinator.com/item?id=12193694](https://news.ycombinator.com/item?id=12193694)

<comment><USER3> Very nice! Thanks.

You might be interested in this paper and code on the implementation of microKanren, a minimal implementation of core miniKanren. The core implementation is under 50 lines of Scheme code.

Jason Hemann and Daniel P. Friedman. microKanren: A Minimal Functional Core for Relational Programming. In Proceedings of the 2013 Workshop on Scheme and Functional Programming (Scheme '13), Alexandria, VA, 2013.

[http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf](http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf)

[https://github.com/jasonhemann/microKanren](https://github.com/jasonhemann/microKanren)

</comment></comment></comment></comment><comment><USER14> So, this is a text editor primarily for scheme, with a GUI for TDD built in?

<comment><USER15> It is an interactive program synthesizer, as it says in the overview

<comment><USER3> Yes, it's a prototype editor with interactive example-based synthesis.

Barliman's synthesis can try to fill in "missing" sub-expressions in a Scheme definition. However, there is also a TDD component that might not be obvious. Barliman will attempt to run each test individually, even if the function has not been fully defined. That is, Barliman will attempt to synthesis a definition of the function to make each test pass. If Barliman can _prove_ that there there is no way to fill in the function definition to make the test pass, the test will display an error message.

In other words, Barliman runs unit tests continually, and those tests can fail _before_ you have finished defining the function being tested. Hopefully this feedback will let the programmer know that they are heading down the wrong path as soon as possible. Or, let the programmer double check the test, to make sure the test is correct.</comment></comment></comment>


How is cable tv going to survive this? - <AUTHOR> https://www.sling.com/ <comment><USER2> I was not a fan--I had their service for a couple of months. The apps need some serious work and you can't watch via their website (I run Linux at home).

My current setup is:

Amazon FireTV

Amazon Prime

HBO Now

Netflix

Hulu Plus (12/mo ad-free version)

I honestly would not even consider switching anywhere else or ever going back to cable.

</comment><comment><USER3> First time i hear about this and right away considering signing up.</comment>


Sessions met with Russian envoy twice last year, encounters he did not disclose - <AUTHOR> https://www.washingtonpost.com/world/national-security/sessions-spoke-twice-with-russian-ambassador-during-trumps-presidential-campaign-justice-officials-say/2017/03/01/77205eda-feac-11e6-99b4-9e613afeb09f_story.html <comment><USER2> Please don't post garden-variety political stories to HN.

This kind of thing is off-topic here and would easily deluge the site if we didn't actively prevent it from doing so.

<comment><USER3> That kind of "we must actively prevent such stories" censorship approach is exactly what the government is doing.

A story of quite significance to our daily lives is not off topic here.

<comment><USER4> > A story of quite significance to our daily lives is not off topic here.

Well, the site guidelines[1] would disagree with you:

> Off-Topic: Most stories about politics, or crime, or sports, unless they're > evidence of some interesting new phenomenon. Videos of pratfalls or > disasters, or cute animal pictures. If they'd cover it on TV news, it's > probably off-topic.

Again, _If they 'd cover it on TV news, it's probably off-topic._

[1] [https://news.ycombinator.com/newsguidelines.html](https://news.ycombinator.com/newsguidelines.html)

<comment><USER5> The Trump kakistocracy is nothing if not an interesting new phenomenon.

<comment><USER2> It looks like you've been using HN primarily for political/ideological arguments. That's not what this site is for, so please stop using it that way.

<comment><USER5> I have avoided posting political/ideological arguments in topics that aren't about politics or ideology in the first place. But it's your site and your rules, so consider this account closed.

</comment></comment></comment></comment></comment></comment><comment><USER6> "Sessions last year had more than 25 conversations with foreign ambassadors as a senior member of the Armed Services Committee, including the British, Korean, Japanese, Polish, Indian, Chinese, Canadian, Australian and German ambassadors, in addition to Kislyak"

Ehh, I probably buy this "I didn't meet him as a Trump surrogate" line(he was head of Senate Armed Services committee?), but this is exactly the kind of pointless reactionary conspiracy fueled pablum that the Trump campaign ran against Clinton. You made the bed, now lay in it.

<comment><USER7> Meeting with a government ambassador in your role as head of the Senate Armed Services committee and claiming you didn't talk about the election is a far cry from meeting with the Attorney General potentially set to potentially prosecute your wife and claiming you only discussed your grandchildren.

<comment><USER6> The problem here is that there is objectively no difference between the two scenarios you laid out (because there is no evidence either way). It is purely a matter of "optics" in both situations (trust or lack thereof), so your interpretation is wholly dependent on what other news about that particular person you've read.

<comment><USER7> That's a fair assessment.

</comment></comment></comment></comment><comment><USER8> The Fourth Estate is doing its job. Whatever the truth is, the pressure from respected institutions like the Washington Post and New York Times will be a big part of why we eventually find it. I am proud that the press is holding the government accountable.

<comment><USER9> Accountable to what? what is the big deal or any with this "incident"?

<comment><USER10> The guy who wants to be the country's top lawyer was caught perjuring himself in front of congress. Republicans in congress can't ignore this without significant loss of face with their constituents.

</comment></comment></comment><comment><USER11> I'm not a lawyer, but my understanding is that Senate confirmation hearings are under oath, and therefore Sessions has perjured himself. Last I checked, perjury was a felony.

What happens next?

<comment><USER7> There is nothing here to prove that he perjured himself.

From the article: In January, Sen. Patrick J. Leahy (D-Vt.) asked Sessions for answers to written questions. "Several of the President-elect's nominees or senior advisers have Russian ties. Have you been in contact with anyone connected to any part of the Russian government about the 2016 election, either before or after election day?" Leahy wrote.

Sessions responded with one word: "No."

Justice officials said Sessions met with Kislyak on Sept. 8 in his capacity as a member of the armed services panel rather than in his role as a Trump campaign surrogate.

"He was asked during the hearing about communications between Russia and the Trump campaign — not about meetings he took as a senator and a member of the Armed Services Committee," Flores said.

___

Unless they can prove that the meeting was related to the election then it seems unlikely that this was perjury.

<comment><USER12> From the NYT article:

\</comment></comment></comment><comment>----

On Wednesday, a Justice Department official confirmed that Mr. Sessions had two conversations with Ambassador Kislyak last year, when he was still a senator, despite testifying at his Jan. 10 confirmation hearing that he had no contact with the Russians. At that hearing, Mr. Sessions was asked what he would do if it turned out to be true that anyone affiliated with the Trump team had communicated with the Russian government in the course of the campaign. He said he was "not aware of any of those activities."

"I have been called a surrogate at a time or two in that campaign and I didn't have — did not have communications with the Russians, and I'm unable to comment on it," Mr. Sessions said at the time.

</comment><comment><USER13> There are finally investigations being disclosed too. Problem is it seems they want to focus on who illegally leaked the information about contact and meetings.

</comment><comment><USER14> Subscribe now! Support this coverage!

[https://subscribe.washingtonpost.com/](https://subscribe.washingtonpost.com/)

</comment><comment><USER15> Does this put his job in jeopardy, or can republicans keep him in office despite this?

Is there any judicial oversight possible?

<comment><USER16> This is exactly why Flynn resigned, so he's in hot water.

</comment></comment><comment><USER17> Sessions had contact with the Russian ambassador as a member of the Armed Services Committee, not as a campaign surrogate. This is a non-issue.

</comment><comment><USER18> It's great to see the press bringing the duplicity of Trump's cabinet to light. I worry though that they've inured us to scandal. This would undoubtedly be a debilitating scandal for a normal administration, but at this point I think people almost _expect_ Trump and his appointees to tell big lies.</comment>


IOS 4 on 3G(S) slow? Turn off Spotlight - <AUTHOR> http://modmyi.com/forums/general-iphone-chat/717951-ios-4-3g-slow-turn-off-spotlight.html

<comment><AUTHOR> I did a restart afterwards and it seem to make quite a difference (at least for me, I turned everything off), schould work for 3GS as well:

Settings-General-Spotlight search</comment>


Hawking radiation mimicked in the lab - <AUTHOR> http://www.nature.com/news/hawking-radiation-mimicked-in-the-lab-1.16131 <comment><USER2> I have no notable background in physics and cannot identify whether this experiment is a valid analog of Hawking radiation, but it's amazing to me that one could substitute that many conceptual components and still have a strong result.

Then again, the whole process of a billionth-of-a-degree condensate flowing at high velocities to create multiple distinct internal sound barriers that could even _approach_ an effective model of an event horizon is a testament to the patience and creativity of the physicists involved. And when you study something so difficult to observe, you definitely need creativity and patience, right?</comment>


Iostat -x - <AUTHOR> http://dammit.lt/2009/03/11/iostat/

<comment><USER2> Good introduction. This is one of the tools that I first used on Solaris, and Solaris iostat is still a little bit better than linux iostat. I'd especially like to have the '-z' and '-M' options in linux.... Maybe it's time I looked at the source code.

<comment><USER2> This thread is long-dead, but I wanted to add that -M is already in iostat 9.0, as -m. Yesterday's release of 9.0.3 adds -z (if pressed, I'll admit to supplying a patch): <http://pagesperso- orange.fr/sebastien.godard/changelog.html>

</comment></comment><comment><USER3> I personally use "iostat -xk 1" which shows the values in kilobytes rather than blocks (easier to read) and updates every second.

</comment><comment><USER4> Even better is patching Net-SNMP to output %util over SNMP, then pulling the numbers into cacti for various graphs.

</comment><comment><USER5> dstat is also quite nice.</comment>


Real-time web streaming with PlayFramework Iteratees - <AUTHOR> http://blog.greweb.fr/?p=1853

<comment><USER2> Amazing what can be done with ~200 lines of code. Its a little much to wrap your head aroun, but once you do doors just start to open.

</comment><comment><USER3> This needs more up votes.

</comment><comment><USER4> this is cool !</comment>


For traction, should I focus in the quantity or quality of my waiting list? - <AUTHOR>

I'm building the landing page for my mobile app that is going to be available in three or four weeks.
For the user subscription section of the landing page, I'm using mailchimp, but they use double opt-in. Checking out other landing pages about apps, I notice that the majority use simple opt-in when a user subscribe to their waiting list.
My concern is about should I send a confirmation email after a user subscribe to my list to validate that email or  shouldn't do I?
If they need to validate their email, I'm adding friction to the process and some users may no complete the process, but the ones that do, would be people who really want to use the app.
If they only subscribe without confirming their email, the number of subscribers to the waiting list probably will be larger but some emails will be false ones or duplicated ones.
Which one would be better to implement for better traction results?
Hope you can help me. <comment><USER2> I guess that this point you don't want to create a new landing page via launchrock.com because you probably have a web presence already.

Have a look at existing email list providers. They take care of double opt-in, allow you to download the email addresses and (if you wish) you can email customers fast. Better than reinventing everything again. Sounds like your core business is an app, not list management.

Example: [http://help.campaignmonitor.com/topic.aspx?t=13](http://help.campaignmonitor.com/topic.aspx?t=13). On the pricing page look at 'per campaign'. It's really cheap. (I'm not affiliated, there are probably other providers with similar offers)

<comment><AUTHOR> I'm going to edit my submission to be more clear. Thanks for your answer.

</comment></comment><comment><USER3> quality is way more important. friction is ok, if people are not willing to confirm their email how will you get them to download your app?

The best thing you can do now is engage the people who are interested in your app. Don't wait until launch to start communicating. Use the next 3-4 weeks to validate your assumptions by talking to as many people as possible. Making sure your app solves a real problem that your customers want solved is the best way to get traction.

<comment><AUTHOR> Thank you! :)</comment></comment>


Show HN: Git-khaled – Khaledify your commit messages - <AUTHOR> https://github.com/nlaz/git-khaled <comment> K-Wall While a fun project I can't see anyone wanting to use this. Why would you want your commit history filled with messages unrelated to the code changes?

<comment><AUTHOR> It definitely was just a fun project and I made it mostly as a joke. However, you are able to specify your messages which the script plugs into a template string. Totally ridiculous and totally impractical but fun nonetheless. Cheers!</comment></comment>


Sci-Hub Loses Domain Names, but Remains Resilient - <AUTHOR> https://torrentfreak.com/sci-hub-loses-domain-names-but-remains-resilient-171122/ <comment><USER2> Posted on Facebook

      sci-hub.io are being blocked now, use sci-hub.bz or sci-hub.cc to access the website

<comment><USER3> Or the onion website: [http://scihub22266oqcxt.onion/](http://scihub22266oqcxt.onion/)</comment></comment>


National Science Foundation has given UC Irvine $100,000 to research WoW - <AUTHOR> http://sciencedude.freedomblogging.com/2008/09/11/uci-tackles-world-of-warcraft-mystery/ <comment><USER2> is it really that hard to guess the answer?

america values improving things and innovating more. asian cultures value obedience and going with the flow more. americans question stuff more.

plus america has more programmers and more education, and making mods requires writing lua code. if you count up the number of WoW players _who are programmers_ good enough to make mods, in each country, it'll come out more even than just looking at population.

also look at how many of the players have their own computer vs play in a cyber cafe. mods are more convenient to use for people with their own computer, and it's hard to imagine people writing them who don't have their own computer. having your own computer is more common in america.

can i have the 100k now?</comment>


Is it possible to hide certain parts of a website from desktop users? - <AUTHOR>

I have a iPhone website and I want to hide some parts of my site from desktop users.<p>Is there any way to do this? <comment><USER2> You may have some luck asking on: <http://webmasters.stackexchange.com/>

</comment><comment><USER3> Try the device-width media query.

<https://developer.mozilla.org/En/CSS/Media_queries>

<http://mediaqueri.es/></comment>


A French Burglar Who Pulled Off His Generation's Biggest Art Heist - <AUTHOR> https://www.newyorker.com/magazine/2019/01/14/the-french-burglar-who-pulled-off-his-generations-biggest-art-heist <comment><USER2> I wonder how much being exposed to Paris's brilliant art culture inspired Tomic's overwhelming love for art. What kind of criminal might he have been in a more industrial city?

</comment><comment><USER3> It is amazing that something like this is still possible in this day and age. If the story didn't include dates and mentions of Facebook or Lyft, it could be mistaken for having took place 50 years ago.</comment>


Are SUVs Ruining Retirement Savings? - <AUTHOR> http://awealthofcommonsense.com/2018/07/are-suvs-ruining-retirement-savings/ <comment><USER2> This was my favorite paragraph:

> Personal finance experts love to discuss how much money you can save by > avoiding that daily Starbucks habit or packing a brown bag lunch every day > at the office. While I guess you could add to your bottom line somewhat by > cutting back on the little things (a) this stuff doesn't move the needle all > that much, (b) it's the little things in life that can give you small joys > on a daily basis and (c) the large purchases will have a much greater impact > on your bottom line.

This is also a big difference I've noticed between a "rich dad, poor dad" mindset. Sweating the small stuff doesn't make much of the difference in the end, it's the much less frequent but more impactful decisions (where you live, who you marry, the car you buy) that determines your overall financial well- being.

<comment><USER3> > packing a brown bag lunch

What's the significance of a lunch bag being brown in the US?

<comment><USER4> There's no significance really. It's just a stereotypical lunch bag. I think most people use coolers these days, but back in the day you'd pack your sandwhich, chips, and drink in a brown paper bag to take to work.

Something like this.

[https://images-na.ssl-images- amazon.com/images/I/41wfQvGOWFL...](https://images-na.ssl-images- amazon.com/images/I/41wfQvGOWFL._SL500_AC_SS350_.jpg)

<comment><USER5> Except a Thermos bottle instead of a plastic water bottle.

</comment></comment></comment></comment><comment><USER6> This reminds me of a silly joke. 2 friends are talking, one of them has just lit a cigarette.

-"Dude, how much do you smoke? And do you like porsche cars?" -"Around a pack a day. And yeah mate, I love em!" -"Dude a pack per day costs $12. If you stop smoking, you can buy a porsche in under 10 years just from the savings from cigarettes alone..." -"Oh damn, never thought of that. Do you smoke?" -"No, never!" -"So, where is your porsche parked?"

\-----

Now jokes aside. Unless you work towards a goal (eg new laptop at the end of the year), and you actively keep track of the extra savings it's very easy to blow the $4 saved per day on a whim, without even realizing. Your mindset changes to "I can buy drinks for my friends, I 've been saving this week it's cool", and you end up where you started. And that's fine, there is happiness to be had over buying your friends a drink.

</comment><comment><USER7> A lease is a depreciation financing program. It only makes sense if you want to change your car every 3 years.

I think if they called it a Deprecation Financing Program they wouldn't get so many customers.

<comment><USER8> I think they'd have about the same number of customers -- most people I know who lease their car just want to drive something new and not put much effort in to maintaining it. They don't really car about the long term financial downside.

</comment></comment><comment><USER9> Sheesh, you can buy three new cars or a starter home (in some places), that's how expensive new cars are these days.

Auto loans also require you to carry full coverage insurance, which can be the same or more than your car payment if the loan is less than $20,000.

Personally, I can't stomach the idea of paying $500-700/mo for a used vehicle.

My current daily is a 2005 Chevy Aveo, I've owned it about 6 years and my total monthly cost (car, insurance, fuel, maintenance) is under $200/mo. It's a budget box, no frills, and I do all my own repairs and maintenance, and you can too! Youtube is a great resource and cheap hand tools can be found at Harbor Freight. Anyone who tells you that modern vehicles can't be maintained at home is mistaken, most maintenance tasks require no special tools and many repairs are attainable with limited skill and experience.

</comment><comment><USER10> I think my favorite part of the article is this quote: "Personal finance experts love to discuss how much money you can save by avoiding that daily Starbucks habit or packing a brown bag lunch every day at the office." followed by "this stuff doesn't move the needle all that much"

</comment><comment><USER8> I think that buying SUVs are more of a symptom of the problem than the cause. Sure they're expensive to buy, insure, and maintain - but most drivers I see are the only one in their vehicle. People aren't doing what is practical, they're doing what makes comfortable _now_.

</comment><comment><USER11> I found this article interesting because I couldn't for the life of me understand why so many people spend so much money on their cars. For me, a car was just a convenient way to get to where I wanted to go. My ego wasn't tied up in at all. I didn't own a car as a way to show off my status. I drove a series of "beaters" and often did my own maintenance and repair of relatively simple issues. I finally bought exactly one new car for cash, and drove it for twelve years.

I never carried collision or comprehensive insurance, having the opinion that dealing with insurance is always a pain in the ass. The insurance premium is simply a markup on the expected value of what the insurance company would pay out. My "inner mathematician" couldn't permit it.

Because of this, my total cost of ownership of cars was really low. I piled all the money I saved into investing, and came out far ahead.

I sold my last car when I retired. Now, I walk everywhere: to the supermarket, to the park, to the gym, to restaurants, to the downtown bars. I'm so glad not to own a car.

<comment><USER12> What other types of insurance did your inner mathematician prevent you from getting? Did you also skip out on health insurance because the premiums are a markup on the expected value of your health care costs?

<comment><USER13> it's not really applicable to health insurance case because getting it through your employer is tax free, effectively saving you 25% on the cost.

<comment><USER14> I believe it's not just tax free, right, it's just priced into your salary. They won't give you the employer contribution back as cash if you decline, will they?

<comment><USER13> The money that goes towards the health insurance isn't subject to income tax, so it's cheaper than taking the money and buying yourself.

employer provided health insurance:

        $50k salary
        $5k health insurance
        $50k taxable income

buy your own health insurance:

        $50k salary
        $5k in lieu of health insurance
        $55k taxable income

<comment><USER14> But it's better/worse than that. Because they won't pay you $55k if you decline healthcare. Instead, you get paid $50k with the option to get healthcare (take it or leave it).

My family's insurance healthcare isn't tax-free, which would mean saving $2k or $3k or whatever. It's over $10k of insurance a year that I pay less than $2k for.

</comment></comment></comment></comment></comment></comment><comment><USER15> This article is missing a huge and expensive market segment - 4 door pick-up trucks. I was at the dealer last week and found lots of pick-ups in the 55-70k price range. They are seemingly popular here and I get the appeal especially if you want to just toss all your stuff in the back and hit the mountains, but they usually get worse mileage than a SUV and cost just as much.

<comment><USER16> Depending on where you live, pick-ups are not just handy but rather a cultural icon. Have you ever listened to country music? You're not a real country boy if you don't have a pick-up.

The real bait-and-switch though is the disappearing low & middle end of the pick-up market. Pops working the farm didn't drive a $70k luxury F-150. But gone is the Ranger, 1st gen Tacoma, and the much cheaper rough-and-tumble F-series of twenty years ago.

<comment><USER17> Ranger will be back in 2019

<comment><USER18> Not for $11K

</comment></comment></comment></comment><comment><USER19> > Personal finance experts love to discuss how much money you can save by > avoiding that daily Starbucks habit or packing a brown bag lunch every day > at the office.

I actually think the true long term cost savings is in health care costs and general personal health. Making food yourself will cut down on excess salt, sugar and fats which are so prevalent when eating out. This will certainly help you stay healthy in the long run.

That being said, almost all cars are a financial loss and you'd be better off driving a 2000s civic. I always found it ironic that Michigan was loathe to pay for plowing but instead just bought SUVs.

</comment><comment><USER20> "avoid the"..."insane initial depreciation that exists with new cars."

This is a strange statement, because of course lease pricing is nothing more than paying for the depreciation of the vehicle. Not only are you paying for it over the term, the risks if you want to terminate earlier, after the worst of the depreciation, are identical if not even exaggerated with leasing.

It can be a good choice, especially for businesses because it greatly simplifies accounting for vehicles (just an expense and nothing more), but when people differentiate owning from leasing some strange statements are oft made.

</comment><comment><USER21> The 15+yr list has as much or more to do with buyer demographics and consumer behavior as it does to do with actual reliability and value. It's basically a reflection of what vehicles just wound up being popular among demographics that are easy on equipment (the wealthy, the old, etc) 15yr ago.

It's also worth mentioning that when you own the car you need to strike a balance between average use and peak use. Most of the people commuting in crew cab trucks are going to use the second row once a week (same goes for sedans) and the bed once a month. Compared to a owning a smart car and renting a nice sedan for a road trip once a year, taking a taxi a few times a month and paying for delivery/rental trucks it probably doesn't come out even but it's not the massive waste of money it seems like at face value and some of that can be attributed to people wanting luxury (sticking a fridge in the back of a truck is easier than strapping it to a car, having two rows of seating is much more pleasant than once bench for 3+ people). This applies to any excess capacity, it's just most obvious with trucks. Sizing for close to peak needs is why crossovers and SUVs are so popular. They can comfortably fit the family and/or a bunch of stuff. You might not need to do that every week but many people do it often enough to feel justified in springing for the luxury.

If you want to see less massive vehicles on the road then stop acting like you're too good to cram X+1 people in a vehicle that officially seats X or strap stuff to the roof. People buy trucks on the justification that they will haul homeowner sized amounts of lumber or crossovers for a family with two/three kids because they perceive putting three kids in the back seat of a compact and sticking a Christmas tree on the roof to not be in accordance with how someone of their income level is supposed to act.

</comment><comment><USER22> I feel like it's a bit disingenuous to talk about this in the context of 1) paying MSRP and 2) buying new.

He even mentions the second point, then goes on to completely ignore it:

      - Never buy new.
      - Just buy something 2-3 years old after it comes off someone else's lease.

A quick look on Kelley Blue Book says that $51,790 Ford Expedition drops to $24,925 after 3 years and 55,000 miles. Using the same parameters for the loan comes out to payments of $418 per month.

That's still a chunk, but it doesn't have quite the same shock value as the brand-new MSRP prices presented...

Now, $418/mo is still a far cry from the $165/mo you can get out of a lowend, 3-year-old Kia Rio, for sure. I drive something similar now. But the article still kind of rubs me the wrong way...

<comment><USER23> It's not just the extra 250$/month it's also going from 29 city / 37 highway to 17 city / 24 highway plus higher taxes, insurance, and maintenance costs.

Compound this with a family having 2 cars and a couple could be looking at ~2,000$ / month less in retirement. Which for many people would be the difference between comfortable and not.

<comment><USER24> My new car actually had lower insurance because of the safety features built in.

<comment><USER23> We are comparing both models and ages not just one or the other.

Compare a _new_ Ford Expedition vs a 3 year old 3-year-old Kia Rio.

<comment><USER24> Understood. I was specifically referring to this part:

> plus higher taxes, insurance, and maintenance costs.

</comment></comment></comment></comment></comment><comment><USER25> One thing that bugs me about this article is that the author chose the largest and most expensive SUVs, not the ones that are actually popular.

The smaller and more popular RAV4, Rogue, CR-V, Escape, etc aren't mentioned here. Comparatively, nobody buys Tahoes and Sequoias.

</comment><comment><USER26> Minivans aren't cheaper; the Dodge Caravan is cheaper, for both definitions of the word.

</comment><comment><USER27> Just to get this out there from the start: I don't like cars much, and I view them not just as an expense to be minimized, but a life unpleasantness to be minimized. Cars are horrendously expensive and I don't really like parking them, worrying about where I parked them, paying for parking for them, or not being able to have another beer because I'm driving them.

But I do surf and my kids love to fish and ride their bmx bikes in nifty places that are most easily accessed with a car, and I'm cool with that, so I look to balance the lowest cost and lowest hassle way to do that. We do plenty around the neighborhood, but can't do it all around the neighborhood. At least not yet.

So far, the right balance, I've found, is to buy a new car with a reputation for value and reliability. I accept that this isn't the most optimal possibility, but I've always been suspicious of the claim that a car loses x% of its value the moment it drives off the lot. Oh, I certainly agree that this is the case if you want to sell it, but that's hardly just true for cars. Go buy a thousand dollar suit and try to sell it on the street right outside the store where you bought it. It'll lose a lot more value than the car.

But here's the thing, try to _buy_ that car (or that suit) at an x% discount from someone who just drove it off the lot. Even if you can, you might worry (well, I might) about what the hell is going on. It's just... weird.

Ok, so a year or two after it was bought new? Eh, I'm still not convinced. I suppose there are good deals out there, especially around people who dump cars after the lease, but even then, people often don't sell high quality cars that are only 2-3 years old. They sell cars they don't want anymore, and sure, that might be because they aren't brand new and shiny, but you often end up buying problems.

Could just be me. I've had bad experiences buying used cars and good experience buying new cars that I take very good care of for the life of the car. I certainly don't sell it at 3-4 years old, that's when the car is most valuable to me. It's a 3-4 year old car that I know is in great shape and has been cared for properly. I don't know if that is the case with a car that someone planned to dump at the end of the lease (or is selling cause... not sure why). You can have a great experience buying a used car, and on average it probably does work out to be less expensive but I don't like the uncertainty and variance.

Beyond that, I lust for the day I no longer own a car. Kid pick ups and drop offs still make it on the balance better to own one, but it's getting close. Maintenance, gas, parking fees (high in SF where I work), payments (or the lost value of the investment)... even if I buy a sensible car and take care of it and keep it for 10-15 years (until the maintenance costs exceed the value of the car), we're still probably looking at, what $4-6k a year, at least? That includes my very high parking costs. For others, it would be lower. This is when you make an effort to keep the costs down over the lifetime of the car (buying a quality car with a focus on value not luxury and keeping it for the usable life of the car).

I mean, seriously, you can take a lot of ride share for $5k a year. I'm starting to see some interesting things happening - like, I read about a surfing "club" with a monthly fee that has showers and boards and wetsuits and a lounge near the beach. If you're happy just surfing that one break, you could ditch the car and get a ride service, and even if you live a ways from the beach... 5k is a hell of a lot to work with.

Still, some major limitations. But man, I seriously mean it, I drool at the idea of getting rid of cars in my life.

</comment><comment><USER28> I would like to see a similar analysis applied to living and working in Silicon Valley or San Francisco, as opposed to some metro area in the Midwest. I have a hunch that given two similar people, one in each place, with similar careers, financial habits, consumer habits, etc., the one in the Midwest will be able to retire sooner and more comfortably than the one in SV/SF.</comment>


Internship advice? - <AUTHOR>

Hi Guys/Gals,
I am in need of serious advice. I recently applied to an internship in late April. The women that I spoke with via the phone sounded really interested in me and ask me to follow up as soon as classes ended( around mid may ). I reached out to her early June and she stated that she would send me an offer letter in a couple of days and that she was very sorry and stated how busy her current schedule is.
Fast forward, it has been almost 3 weeks and I have not gotten a letter nor an update about the internship. Should I follow-up one more time or simply call it quits and move on? <comment><USER2> 1\. See "How to get coaching, mentoring, and attention:" [http://jakeseliger.com/2010/10/02/how-to-get-your- professors...](http://jakeseliger.com/2010/10/02/how-to-get-your- professors%E2%80%99-attention-or-how-to-get-the-coaching-and-mentorship-you- need/)

2\. Follow-up one more time. Be polite, but persistent, until you get a firm "no."

3\. Dating and workplace dynamics are similar in that there's a lot of signaling and distraction happening simultaneously. Aim for "polite, yet persistent."

</comment><comment><USER3> [http://blog.close.io/follow-up](http://blog.close.io/follow-up) TLDR: Dude followed up with an investor 48 times and got the funding. You can do the same ;)

<comment><AUTHOR> Thanks! After reading that I have finally got the confidence to send a follow up email.

</comment></comment><comment><USER4> I would follow-up one more time, if the place is somewhere where you really want to work. Many people get busy and things slip, especially when dealing with email.

However, I would also look for other internships in the meantime.</comment>


Themes from the Velocity Conference 2019 - <AUTHOR> https://medium.com/memory-leak/3-themes-from-the-velocity-conference-2019-e5165d4afb97 <comment><USER2> These are the same themes I've only ever known to come out of Velocity</comment>


Delta Refuses to Let Passenger Fly Over Shirt (and Race) - <AUTHOR> http://storify.com/I_Am_Arijit/arijit-vs-delta

<comment><USER2> What kind of idiot wears that to an airport? The kind who wants to grandstand about free speech.

Knowing that people are dumb as bricks, and that airport security has no sense of humor, he should have chosen a different shirt. Don't poke the bear and then complain when he bites you.

<comment><USER3> Your criticism reveals an unsound technical background..."By wearing that scantily clad outfit she was just asking for it (rape)."

<comment><USER2> ad hominem plus non sequitor. Nice argument.

Refute my premise that being a jerk to airport security is a bad idea.</comment></comment></comment>