I've Got Nothing to Hide' and Other Misunderstandings of Privacy (2014) - <AUTHOR> https://papers.ssrn.com/sol3/papers.cfm?abstract_id=998565 <comment><USER2> _Arguing that you don 't care about the right to privacy because you have nothing to hide is no different than saying you don't care about free speech because you have nothing to say._

[https://en.wikiquote.org/wiki/Edward_Snowden#2015](https://en.wikiquote.org/wiki/Edward_Snowden#2015)

<comment><USER3> Also, one of the hardest-hitting quotes from his book, Permanent Record:

 _" There is, simply, no way, to ignore privacy. Because a citizenry's freedoms are interdependent, to surrender your own privacy is really to surrender everyone's. You might choose to give it up out of convenience, or under the popular pretext that privacy is only required by those who have something to hide. But saying that you don't need or want privacy because you have nothing to hide is to assume that no one should have, or could have to hide anything – including their immigration status, unemployment history, financial history, and health records. You're assuming that no one, including yourself, might object to revealing to anyone information about their religious beliefs, political affiliations and sexual activities, as casually as some choose to reveal their movie and music tastes and reading preferences.

Ultimately, saying that you don't care about privacy because you have nothing to hide is no different from saying you don't care about freedom of speech because you have nothing to say. Or that you don't care about freedom of the press because you don't like to read. Or that you don't care about freedom of religion because you don't believe in God. Or that you don't care about the freedom to peaceably assemble because you're a lazy, antisocial agoraphobe. Just because this or that freedom might not have meaning to you today doesn't mean that that it doesn't or won't have meaning tomorrow, to you, or to your neighbor – or to the crowds of principled dissidents I was following on my phone who were protesting halfway across the planet, hoping to gain just a fraction of the freedom that my country was busily dismantling."_

― Edward Snowden, Permanent Record, p. 208

[https://www.goodreads.com/work/quotes/71198843-permanent- rec...](https://www.goodreads.com/work/quotes/71198843-permanent-record)

<comment><USER4> Adding to that: by giving up your freedom (of _X_ ) you may be giving it up for those around you. We interact with people and information about others can be gleaned by what we do.

Privacy-conscious people may not use Gmail because they don't like what Google is doing, but if everyone you communicate with has an @gmail.com address, you're being 'compromised' every time you send a message to them.

</comment></comment></comment><comment><USER5> Doesn't look like many are reading the actual article. It sets up the "nothing to hide" argument as the following, which is quite a bit more difficult to rebut:

" Therefore, in a more compelling form than is often expressed in popular discourse, the nothing to hide argument proceeds as follows: The NSA surveillance, data mining, or other government information- gathering programs will result in the disclosure of particular pieces of information to a few government officials, or perhaps only to government computers. This very limited disclosure of the particular information involved is not likely to be threatening to the privacy of law-abiding citizens. Only those who are engaged in illegal activities have a reason to hide this information. Although there may be some cases in which the information might be sensitive or embarrassing to law-abiding citizens, the limited disclosure lessens the threat to privacy. Moreover, the security interest in detecting, investigating, and preventing terrorist attacks is very high and outweighs whatever minimal or moderate privacy interests law-abiding citizens may have in these particular pieces of information.

Cast in this manner, the nothing to hide argument is a formidable one."

<comment><USER6> I'd like to turn the conversation around and question the prioritization of surveillance of the people over the transparency of politicians' communications, sources of funding, who they're meeting with and all such related activities they perform in a role servicing and paid for by the public.

Only once this is addressed should we move down the priority list to "blanket communication and behavioural surveillance of the citizenry."

The potential for harm to a country and it's citizens caused by political decisions is exponentially greater than any act by an individual or group with no political power. (and whilst this point is arguable and weighted with emotion, this includes 9/11).

<comment><USER7> >Moreover, the security interest in detecting, investigating, and preventing terrorist attacks is very high and outweighs whatever minimal or moderate privacy interests law-abiding citizens may have in these particular pieces of information.

No thank you, I'd give up my privacy if it could help prevent heart attacks, cancer or maybe even automobile crashes but terrorism compared to the above pale in comparison when you consider the number of deaths. Literally giving up one of the fundamentals the country was founded on for something so minor is clearly a reach of power for the government to control the population under the guise of keeping them secure.

[https://ourworldindata.org/uploads/2019/05/Causes-of- death-i...](https://ourworldindata.org/uploads/2019/05/Causes-of-death-in-USA- vs.-media-coverage.png)

[https://ourworldindata.org/terrorism](https://ourworldindata.org/terrorism)

</comment></comment></comment><comment><AUTHOR> A link to direct PDF: [https://www.cs.drexel.edu/~greenie/privacy/solove.pdf](https://www.cs.drexel.edu/~greenie/privacy/solove.pdf)

@dang you might want to edit the URL to this

</comment><comment><USER8> "Give me six lines written by the most honest man in the world, and I will find enough in them to hang him."

<comment><USER9> This does not make the point you're thinking it does.

<comment><USER10> How do you know what he is thinking?

<comment><USER11> Context of course.

Since he posted it in this thread, he should obviously thinks it makes a point relevant to privacy.

But the quote is not about privacy. "Give me six lines" just means that anything said/written by someone could be misconstrued against them, not just their private communications.

(Of course it would also apply to things communicated in private, and perhaps even more so since one would say even more damning things there. But it's not meant to be a warning about them, but about how anyone can something something that can be used against them, privately or not).

<comment><USER8> >But it's not meant to be a warning about [private communication], but about how anyone can something something that can be used against them, privately or not

Okay, the internet was created for military communications. So, with your logic, you should have a problem with it being used to power eCommerce, pornography, YouTube, Facebook and hacker news.

This ain't literature class.

<comment><USER11> > _Okay, the internet was created for military communications. So, with your > logic, you should have a problem with it being used to power eCommerce, > pornography, YouTube, Facebook and hacker news._

Not with "my logic", but with the logic of some strawman, who claimed something really unrelated to my point.

I didn't say that "nothing can't be used outside of its original stated purpose".

I said that a specific quote about how anybody can find some damning thing in what others have wrote/said to attack them with, is not the same as a quote about privacy.

That is, it's intented message not:

"It's good to keep your writings/letters/etc private because else someone might find stuff in them to use against you"

but:

"I -as a skilled manipulator- can take any random stuff wrote/said by even the most innocent man and it against them to make them appear guilty".

<comment><USER8> >I said that a specific quote about how anybody can FIND some damning thing in what others have wrote/said to attack them with, is not the same as a quote about privacy

The act of FINDING anything one has said/written is privacy related.

>I -as a skilled manipulator- can take any random stuff wrote/said by even the most innocent man and it against them to make them appear guilty".

Good point. Let's put the quote in context. Gestapo, Nazi Germany's secret police is where this quote supposedly originated. They had a country-wide spy network to monitor what people said.

Data manipulation can't happen without data. Without the collection and storing of conversations, breaking into people's homes, intercepting mails/telephone/telegraph correspondence, no manipulation of the "words" could have happened.

The point is - A skilled manipulator won't find anything to hang me unless he's invading my privacy in the first place. (Assuming I don't give public speeches or write publicly)

<comment><USER11> > _Gestapo, Nazi Germany 's secret police is where this quote supposedly > originated. They had a country-wide spy network to monitor what people > said._

The quote is attributed to cardinal Richelieu, and whether it's his or not, exists for at least 2 centuries, so before the Gestapo and modern surveillance.

> _Data manipulation can 't happen without data._

Which is neither here, nor there. I agree that privacy is important, and that surveillance offers all kinds of opportunities for that.

My point is that the quote wasn't intended originally as a comment on that, and it is out of place related to that, because it intends to emphasize the inverse: you don't need "data", just any 6 lines will do.

> _The point is - A skilled manipulator won 't find anything to hang me unless > he's invading my privacy in the first place._

That's a point one can make. It might even be a point I agree with.

It's not however the point the quote was making. And it's only that which I'm pointing here, not the merits or not of privacy/surveillance.

The quote was making the inverse point: "Who cares for data and deep secrets, and notebooks, and spying, and so on. I just need any old 6 lines from someone and can have them hanged".

Might be too arrogant for Richelieu (or whoever said it) to think so. Might not even be realistic. But even metaphorically, it's purpose was to convey:

"Anything someone says can be used and misconstrued against them".

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER12> This "nothing to hide" discussions always remind me of this great essay "We should all have something to hide": [https://moxie.org/blog/we-should-all- have-something-to-hide/](https://moxie.org/blog/we-should-all-have-something- to-hide/)

</comment><comment><USER13> I find this article underwhelming. It does not really build a strong case. I personally, am person about as interesting or uninteresting as a few billion other people in the world, or as a few hundred million people in the United States. Privacy advocates tend to paint a picture like in the movies "Conspiracy Theory" or "Enemy of the State": if you find yourself in the crosshairs of the state, you're in trouble. Well, here's the thing: I'm not Mel Gibson, and I'm not Will Smith. The chance of the state finding my person interesting is fairly reduced. If someone wants to make my life miserable, there are probably a few hundred guys working for Google who can read my every email on my gmail account, and who can probably even impersonate me on the internet. There are scores of other tech guys working in some bank who can see my every bank transaction, or every credit card payment, or engineers at Amazon who can see the history of my purchases. Pretty much only those who don't want can't find my physical address, or my phone number, or other things. Given all that, the fact that the NSA can do all these things too, well I, for one, am not losing a lot of sleep over this.

</comment><comment><USER14> It's ironic that the "global electronic village" turns out to be just like a real village -- there's very little privacy.

</comment><comment><USER15> The most important thing I've learned from watching Cia and FBI shills being interviewed on CNBC is that in order to preserve our rights we must first be willing to surrender them.

Security and privacy are not diametrically opposed concepts. They are directly dependent on one another. You can't have one without the other.

<comment><USER16> This makes no sense. Both the paragraphs and the sentences contradict each other while repeating cliches from past discussions on this topic. It reads like a markov bot account. You might want to explain what you mean better.

</comment></comment><comment><USER17> _According to the nothing to hide argument, there is no threat to privacy unless the government uncovers unlawful activity, in which case a person has no legitimate justification to claim that it remain private._

This is a surprisingly common sentiment in HN when it relates to financial privacy.

Laws that criminalize financial privacy, aka KYC/AML laws, are justified with precisely this "nothing to hide" argument geared to money laundering and other financial crimes, and said laws are quite popular with the tech intelligentsia.

</comment><comment><USER18> Conclusion from the pdf:

Whether explicit or not, conceptions of privacy underpin nearly every argument made about privacy, even the common quip "I've got nothing to hide." As I have sought to demonstrate in this essay, understanding privacy as a pluralistic conception reveals that we are often talking past each other when discussing privacy issues. By focusing more specifically on the related problems under the rubric of "privacy," we can better address each problem rather than ignore or conflate them. The "nothing to hide" argument speaks to some problems, but not to others. It represents a singular and narrow way of conceiving of privacy, and it wins by excluding consideration of the other problems often raised in government surveillance and data mining programs. When engaged with directly, the "nothing to hide" argument can ensnare, for it forces the debate to focus on its narrow understanding of privacy. But when confronted with the plurality of privacy problems implicated by government data collection and use beyond surveillance and disclosure, the "nothing to hide" argument, in the end, has nothing to say.

</comment><comment><USER19> "Nothing to hide" does not mean "nothing private". "Nothing to hide" means "no unlawful action". It's another thing alltogether from having private things.

<comment><USER20> The way I heard it expressed was "there's a difference between secrecy and privacy; you know exactly what I'm doing in the bathroom but I still don't want you watching."

</comment></comment><comment><USER21> The right to privacy is the right to decide what you want to share or not.

<comment><USER22> And _with whom_.

</comment></comment><comment><USER23> In my opinion the nothing to hide argument is valid in a personal basis, but not in a policy making basis. I am against the surveillance of citizens in the name of security, and I actively support the EFF in their attempts to stop it, but I do not have a sticker covering my webcam because if someone at NSA is spending his afternoons watching me working, and maybe putting the finger in my nose from time to time, I sincerely don't care.

<comment><USER16> Limiting the conversation to what is seen on a webcam doesn't come close to covering the scope of what could happen.

Let's say your screen is captured as well. And sometimes that screen will contain personal and private information of friends and family who might care.

It is not your call to decide for them whether their information should be put at risk or not by an organization that has proved itself capable of leaking like a sieve.

You could argue that your devices contain no names of friends or pictures or contact info or messages of any sort with anyone. OK, but that would be pretty unusual.

Saying you don't care is like driving drunk on an empty road with passengers in the car. You may not care about whether you die, but you have passengers. Your caring about yourself or not isn't the issue.

<comment><USER23> I think you misunderstood my comment (being honest, it was not very well redacted). I do not disagree with anything you said at all, on the contrary. What I mean is precisely that a lack of personal reasons to keep your privacy is not a good reason to not push for privacy policies. I am totally against screen capturing, as I am against surveillance using laptop cameras or phone microphones, or public cameras capturing my face.

However, even although I care about this and actively oppose these practices, I don't cover my face when I live my home, for example, and I don't think (some people may disagree) that I should. Of course, once this affect more people, it is not my choice to not care, and I will do everything possible to keep other people privacy.

</comment></comment></comment><comment><USER24> Exactly the opposite nihilistic enough that I am waiting to be caught and thrown in prison (deep web sins)

</comment><comment><USER25> Sure you have: your SSN, your password, your mother's maiden name, you first pet's name, your relationship with your wife/kids/mother. It's no one else's business.

</comment><comment><USER26> "I have done nothing wrong" => "I have nothing to hide" iff everyone is good and always will be good in the future and never punish me unless I do something wrong.

<comment><USER16> And iff the definition of good will never change.

<comment><USER27> A problematic assumption, as we're already seeing with the ongoing stream of old-Twitter-post scandals.

</comment></comment></comment><comment><USER28> Won't open PDF without me signing up. :-(

<comment><AUTHOR> Direct link to PDF: [https://www.cs.drexel.edu/~greenie/privacy/solove.pdf](https://www.cs.drexel.edu/~greenie/privacy/solove.pdf)

</comment></comment><comment><USER29> Edit: oops, can't link directly to pdf :)

<comment><USER30> Nope

</comment></comment><comment><USER31> If I am to be surveilled anyway, perhaps they can ensure my protection from threats to my privacy?

After all I assume they're doing all this for our protection, not to generate crimes?

</comment><comment><USER32> I've got nothing to show, therefore no reason to be surveilled.

<comment><USER29> saying is showing, showing is saying. You've got nothing to say?

</comment></comment><comment><USER33> tl;dr NSA surveillance _could_ have chilling effects (no evidence either way) and the author has concerns about oversight and accountability.

Pretty unconvincing IMO. The real issue is selective enforcement, e.g. cops who bomb a house to smithereens in pursuit of a suspect but then have sovereign immunity so don't have any consequences. And similarly city officials tend to throw the book of regulations at people they don't like.

<comment><USER34> I agree, the information that can be gathered and probably has been gathered would constitute an invalid search/seizure for that information to have been got only a few decades ago. Now the information is there for the taking and so whatever personal power struggle with the government is way under gunned. Any one can be squashed at the whim. And ultimately there needs to be a strong press/codes to air/catch the unjust application of the power.</comment></comment>


New Number Systems Seek Their Lost Primes - <AUTHOR> https://www.quantamagazine.org/ideal-numbers-seek-their-lost-primes-20170302 <comment><USER2> _All four of those factors are prime in the new number ring, giving 6 a dual existence_

Those factors are irreducibles, but they aren't primes, which is the reason why the uniqueness of factorization fails.

A nonzero non unit element of a ring is called prime if p|ab implies p|a or p|b.

A nonzero non unit element of a ring is called irreducible if p=ab implies that a is a unit or b is a unit (invertible element).

Primes are irreducibles in an integral domain, but the converse is true in unique factorization domains and Z[√-5] is not one.

<comment><USER3> That's a statement that goes quite against the claims of the article and I kinda want to ask for a citation ... But I already feel that this discussion is way over my head and I wouldn't understand any journal articles that would clear this up ...

<comment><USER2> Wikipedia isn't a good source, but it uses 3 as an element of Z[√-5] as an example so it's quite relevant: [https://en.m.wikipedia.org/wiki/Irreducible_element](https://en.m.wikipedia.org/wiki/Irreducible_element)

For a more serious reference any abstract algebra book covering rings and UFDs should do, for example it is in Dummit & Foote.

</comment></comment></comment><comment><USER4> > Mathematicians call this new system a number "ring"; they can create an > infinite variety of them, depending on the new values they choose to > incorporate.

Isn't this a little wrong?

As far as I remember ring is any set with multiplication, negation, and addition defined so that they satisfy a few conditions. No need for the "\+ b * something" part. The usual integer numbers we use form a ring too, as well as booleans.

I might be missing something, and it's irrelevant to the main subject of the article.

<comment><USER5> "Number ring" has a specific meaning [0]. I am not sure if it is equivalent to the integers adjoined with some element though.

>In fact the usual integer numbers we use form a ring too.

Depending on definitions, the integers can be viewed as the ring of even numbers adjoined with the element 1. This does require that we do not define rings to necessarily contain 1. In my experience this definition is is becoming more of a historical footnote though.

There is also a natural generalization of adjoining multiple elements to the natural numbers (which still results in a ring) In this case, the natural numbers would just be a special case of adjoining 0 elements.

The ring of real numbers, in contrast, cannot be constructed by adjoining any finite set of elements to the integers.

The ring of integers mod n is also a ring, but does not contain the integers as a subring (and therefore cannot be thought of as the integers adjoined with any set (finite or infinite) of elements).

The polynomials with coeficients mod n form a non-finite ring which does not contain the integers.

I suspect the point that the author was attempting to make was just that Z[√5] formed a type of structure that mathematicians are familiar with.

[0] [http://mathworld.wolfram.com/NumberRing.html](http://mathworld.wolfram.com/NumberRing.html)

<comment><USER4> Oh, right, that's what I missed, number ring isn't just a ring of numbers. Thanks.

</comment></comment></comment><comment><USER6> What a missed opportunity, not to title this article "In Search of Lost Primes".

(inb4 all the Proust fans downmod me to oblivion)

</comment><comment><USER7> "Recall that every group has a zero element that, when added to any other number, leaves that number unchanged" not so fast.

<comment><USER8> Uh, up to notation, a group better have such an element - otherwise it isn't a group!

<comment><USER9> You're right, but phrasing things in terms of addition and zero is possibly taking some liberties with the definition of group. Even if additive groups and general groups are isomorphic, I agree it's a bit misleading to use additive group naming to provide a lay definition of "group".</comment></comment></comment>


Code boilerplate: Is it always bad? - <AUTHOR> https://medium.com/@shazow/code-boilerplate-is-it-always-bad-934827efcfc7 <comment><USER2> This is a hilariously bad take. If we follow the argument to its natural conclusion then go is itself a poor choice of language. After all, go removes memory management boilerplate in favor of an automated gc system. By the author's argument go should force you to manage your memory yourself. In fact, we really should all just code in assembly because it has the clearest relationship between code and what is going on under the hood. True, coding in assembly requires a lot of needless boilerplate but by this article's argument that's actually a feature.

Go has so many truly bad design decisions (lack of generics being the most damning) and it's sad to see its fanboys try to argue that they're actually good.

</comment><comment><USER3> I always write terse code, not only because it reduces the number of lines (which is important to me) but also because:

\- You clearly state the atomicity, that this thing happening in 1 long line is specific thought, intent, desire - it shouldn't really be on multiple lines - its easier to remove/comment out intent (as it is always self contained), replace it, optionalize it and reuse it.

\- Scrolling the code is damaging to the focus.

\- Once you learned the specific methods used to create terse code seeing it repeated all over again you will become more proficient in reading the code all around.

\- Its way more fun. Its like poetry in programming - why would we all write dummy boring stories. Language is everything (obligatory babel 17 mention: [https://en.wikipedia.org/wiki/Babel-17](https://en.wikipedia.org/wiki/Babel-17))

</comment><comment><USER4> _" By the time I'm done—adding more recovery scenarios, better logging, augmenting errors with more context, handle more edge cases—most of my boilerplate gets a lot more interesting. I did not realize that good boilerplate could be fertile ground for iteration."_

This point makes sense, however I think I like to have my cake and eat it too. Java 8's stream constructions can be relatively terse, but if you need to switch back to a for loop, IntelliJ has nifty right-click menu items for doing so. I think the argument made by TFA is at least related to John Carmack's take on inlining vs. abstraction: [http://number- none.com/blow/john_carmack_on_inlined_code.htm...](http://number- none.com/blow/john_carmack_on_inlined_code.html)

<comment><USER5> I followed Carmack's suggestion and never looked back. I write simpler code on average now, and I spend less time having to re-read it too because I'm changing the same lines less often. What I lose in terseness in the short- term, I regain in being able to spot key abstractions that are more crucial to long-term program health. It plays well with debugging since there are fewer places where state can act at a distance.

It's very unfashionable advice in some circles, though. It sounds just enough like "go back to writing unstructured copy-paste spaghetti" to trigger some people's kneejerk. But the ground rules of "don't take subroutines, don't jump backwards" actually keep it from getting too far out of control, because they align you towards code that only uses enough flexibility for the task at hand, hence there's a lower likelihood of missing something. Very good practice for greenfield code where you might reflexively add a generalization that you don't use. I can still get better at it.

Edit: And one of the most important things it taught me, is that I can use scope blocks and a comment instead of a function, and it'll be sufficient.

</comment></comment><comment><USER6> Interesting take. I think everyone can find _something_ in this with which to agree, so I don't think it's a particularly polarizing way of thinking, but I haven't seen terminology like this used to describe it before. I fall into the same psychological trap in C++ that the author falls into with Python: the "if this is over here instead it's more [elegant/right/concise/impressive/less boilerplatey]". Unfortunately, I find it too tempting to value beauty and elegance (and often masking real weight and complexity) over the in-your-face 'rawness' of simple loops, branches and so on. In Go this is harder to do in general, so you only try for so long before you learn not to fight it. This comment really spoke to me:

> _Maybe this is subjective but I posit that the code's shape looks more like > what it is._

Indentation isn't merely stylistic or syntactic, but it tells us useful things about code at these lower levels. A more complex code shape should convey more complex logic, and we should want that complexity apparent to us...at least sometimes. It looks great to have a nice, terse one-liner, but visually flattening possible control flow paths feels really nasty.

<comment><USER7> I didn't agree with anything. The Python version is leagues better.

</comment></comment><comment><USER8> "Man inadvertently discovers reason for monads and strong typing while writing Medium post"

</comment><comment><USER9> > Any time we write similar-looking code over and over, that's considered > boilerplate.

That's not what boilerplate code is, and DRY is not the way you get rid of boilerplate (the article claims it is a part of the solution).

boilerplate is a repeated preamble that's necessary and unchanging in order to get down to the business of actual logic.

An easy example of boilerplate would be include guards in a C/C++ header file, or 'use strict' in perl.

For example, the author says this:

> When I write Go, I noticed that my tweaks almost always go exactly where > they naturally belong. My boilerplate doesn't stay untouched!

If you're "touching your boilerplate" while writing code that affects the logic of your system, then it isn't boilerplate.

<comment><USER10> Boilerplate can be common and still be tedious.

Those examples are just clear indications that languages sometimes have really terrible default behaviors. Namely, Perl should have been strict by default (with a "no strict" if this didn't perform well enough), and C++ should have at least added #import.

</comment></comment><comment><USER11> To take an analogy, it is similar to saying that we should use small words when trying to communicate. But once you understand the meaning of the more complex words, it is more fluent to communicate in terms of the longer words which represent the abstract concept more concisely and correctly. Of course it actually holds true to some extent in case of spoken languages, but that is because your intended audience is not expected to understand all the words in the dictionary. But the programmer who is reading the code is expected to understand the whole dictionary of python, including all the keywords, constructs and idioms.

It gave me some thought, but ultimately I think don't think it is a correct argument.

<comment><USER12> To take your analogy to its conclusion, we don't want to communicate only using small words, true, but we don't want to communicate only using big words, either.

Ain't nobody (= most people) got time for Hegel :)

I suspect that's why some of the very "expressive", i.e. dense languages, aren't widely adopted.

</comment></comment><comment><USER13> Yes. By using higher level constructs, it is much easier to see what is going on in the code. If there are too many lines, it is much more difficult to understand a piece of code as a whole.

</comment><comment><USER14> I iterate code like he does, then when it gets to where it's doing what I want it to do, I refactor it to make it more readable even if it reduces iterability. After the initial phase of writing the code, going back and forth, etc, the code is going to be read many more times than edited, if in the future it needs to be edited again, the future editor can refactor the nice looking code into whatever shape, and the important thing was that future editor understood my code in the first place, and I hope that future editor, when done editing, will refactor the code into being easily read for the next person, too.

</comment><comment><USER15> It seems he have been writing code so clever and compact that he didn't dare to change it when it came to refactoring time:

> I'd take any opportunity to write terse code. It feels good to be clever

> I noticed that when I wrote Python code, I would often go out of my way to > avoid messing up a beautiful terse set of lines by moving logic to places > other than where it might naturally belong.

I can see how a less expressive language might help with this problem, but I think a better solution would be to rein in the cleverness and focus on readability rather than shortness.

<comment><USER16> I think it's related to the iron law of abstractions. It's easier to change code that has no abstraction than the wrong abstraction. The right abstraction is better than both those, of course, but is often difficult to identify upfront.

<comment><USER17> Succinctly put. I have observed a tangentially related correlation: The code that needs least understanding to change will be the code changed, until it isn't the code needing the least understanding any more.

In unison they sort of tells us why pragmatism is often good when we start writing code, but how we must always try to push towards finding (good) abstractions as the work progress.

</comment></comment></comment><comment><USER18> In the article:

I was expecting a discussion about boilerplate but the author writes about how ugly/bad is code that does a lot of operations in one line.

Then he introduces the concept of "proportionality", and according to it, assembler must be the best language since the program statements are directly proportional to the operations to be performed...

Suddenly high level programming is no longer good stuff...

Meanwhile no real discussion about boilerplate!!

Whenever your code shows implicit patterns that get repeated but cannot be abstracted away using code, you have boilerplate and boilerplate is almost always a bad thing. Your choices are then:

1\. Pretend those patterns as a good thing.

2\. Switch to a more powerful language and destroy the boilerplate either because it isn't necessary anymore, or because you can abstract it away with, for example, a macro.

<comment><AUTHOR>
        > Then he introduces the concept of "proportionality", and
        > according to it, assembler must be the best language since
        > the program statements are directly proportional to the
        > operations to be performed...
        >
        > Suddenly high level programming is no longer good stuff...

Looks like you didn't understand what he meant in that section if you think he implied Assembly is better than high level languages. It's not that 1 line of code should do exactly 1 unit of work, but rather that if 1 line does 100 units, then 10 lines should do 1000.

Function calls are exempt from that, because everyone understands that a function can do arbitrary amount of work, and one needs to know what it does (by reading its name and documentation). The cost is considered to be a "function call".

Yes, Assembly also has high proportionality, which is a benefit to it. But it doesn't mean all other languages are bad. These are tradeoffs.

The point is that it's a beneficial property of a language when you have code length that better corresponds to the amount of work it's doing.

<comment><USER18> > but rather that if 1 line does 100 units, then 10 lines should do 1000.

Why they should? It has no reason to be that way.

If anything, 1 line should do 1000, if possible. Some lines will do 1, others 10, others 5, others 100. "Proportionality" adds no value and, quite the opposite, discourages programming at the highest level possible.

<comment><AUTHOR> > "Proportionality" adds no value

I think it helps improve readability of the code.

</comment></comment></comment></comment><comment><USER19> The title is significantly more ambitious than the content. I think "Go: I have found my Blub" would be more accurate.

</comment><comment><USER20> Meaningful names are critical for understanding. Without good names, it's incomprehensible, regardless of the complexity.

<comment><USER21> Exactly.

If you abstract things but don't give meaningful enough names, you loose everything (because your callers are still forced to lookup the definitions of your abstractions, and now this definition can be hard to search for).

</comment></comment><comment><USER22> The proportionality argument is bunk, straw-man level bunk. Consider what goes on every time go accesses an object, casts to an interface or writes to a channel. Huge, complex code under the covers, way more than the Python examples he's given. What this article really says is "There are abstractions I'm not as comfortable processing as others, therefore those abstractions are bad."

If having code be proportional to complexity was a good idea, we'd all be writing in assembly and subroutines would be frowned on.

<comment><USER23> I think having code be proportional to 'complexity' is good, but having it be proportional to 'work' makes no sense. Personally I find things 'simple' when they only require one level of abstraction, such as accessing an object, or performing arithmetic operations on algebraic objects (e.g. multiplying matrices). And complex when they require more (e.g. manipulating the coefficients of two matrices to define their matrix product).

Boilerplate is when you requires more code than the complexity requires, usually because the language doesn't provide a sufficient opportunity for abstraction.

Note that, if we define a '->' operator that roughly expands to the following:

        (x, err) -> f :
            if (err != nil) {
                 return nil, err
            }
            return f(x);

Then the entire code he wrote as an example of boilerplate can be written as

        DoSomething -> SomethingElse -> MoreWork;

with some minor differences that could be optimized away in the right language.

</comment></comment><comment><USER24> You can write code like Hemingway (simple) or like Shakespeare (dense). Hard to say whether one is better than the other without some attempt to quantify and measure things. Seems more like just a preference.

In regard to boilerplate the author brings up an interesting point that with a good language, the boilerplate can effectively disappear once all the code has been written. If people are worried that boilerplate violates DRY, I think they worry too much.

The best way I've found to determine whether a codebase is good or not is to take someone who's never worked with the code before and ask them to fix a bug or make an enhancement. If that's an excruciating task but would have been easy in a greenfield project, the code sucks.

</comment><comment><USER25> It's not true for all languages, but I actually like Erlang's boilerplate. Almost every OTP project has the same structure, and a very close set of primitives that drive the setup and structure of the application. It can be annoying to setup and get right, but its a common set of structure and patterns which make it much easier to dive into a large project.

So for me it is not always bad, just usually, with some specific exemptions that I think are done well.

</comment><comment><USER21> [https://vimeo.com/9270320](https://vimeo.com/9270320) (Greg Wilson - What We Actually Know About Software Development, and Why We Believe It's True).

It seems we have scientific data showing that the number of code lines one can review per day doesn't depend on the programming language. This means one would spend a lot more time reviewing this C++ code if you looking at the manually-rewritten-to-assembly version instead.

This is a very good argument supporting programming at the highest possible level of abstraction, which is the exact opposite of boilerplate and verbosity.

So please let's not rationalize/stockholm-syndrome over the limitations of any programming language ; boilerplace and verbosity are always bad.

</comment><comment><USER26> So expressiveness of a language is now seen as a bad thing?

<comment><USER27> Among golang developers, yes.

</comment></comment><comment><USER28> More bad excuses for not having exceptions in your language ...

</comment><comment><USER29>
        b = sum((j if j % 2 else 0) for (j, k) in results if k)

This definitely is borderline unreadable but that isn't necessarily because it does a lot of things. It is because it does a lot of things without order and with a lot of line noise. Compare it with

        sum [j | (j, True) <- results, odd j]

or

        filter snd >>> map fst >>> filter odd >>> sum

The bigger problem is that this carries a bool around. If it is only used for filtering filter it beforehand.

The _Opportunity for correction_ is an interesting idea but the authors issue mostly come from a lack of referential transparency. In a pure language refactoring wouldn't be an issue so one could argue this is a symptom of too little abstraction, not too much.

<comment><USER30> If you'd name your variables all three would be perfectly readable I bet.

<comment><USER29> Technically the third has no variables...

Slightly less wise-ass, I couldn't come up with a use case for this code that'd give sane variable names. Third attempt:

        sum $ do
            (element, True) <- results
            guard (odd element)
            return element

That's pretty far from imperative languages, though, which I kind of tried to avoid.

</comment></comment></comment><comment><USER31> I find the number of mistakes I made scales at least linearly with the number of lines I write. Boilerplate is bad because it allows me to write more.

</comment><comment><USER32> I assumed the title was about boilerplate in terms of some skeleton or framework you download. Turns out this is different from what youre talking about (verbosity). Its interesting that even in programming jargon we have two uses for the same term. They are not totally separate though. The repetitive, DRY violations eventually get abstracted into a framework, at which point the boilerplate becomes ok. And if its still too verbose, than another boiler may arose to encompass it.

<comment><USER9> The author doesn't understand what boilerplate means.

<comment> w-ll >> Any time we write similar-looking code over and over, that's considered _copy-pasta_.

is what i'd call it.

</comment></comment></comment><comment><USER33> When I see the error-handling examples, I think that the problem with this kind of "boilerplate" is that it's easily forgotten. This results in errors being eaten and that's bad. But I agree with the main point that "proportionality" of code is a good thing.

</comment><comment><USER34> From the maintenance perspective I would prefer the more verbose code in most cases, because it is easier to debug. Moving the verbose code block to a method or function for reuse will fulfill the DRY principle as well. Then you can decide during debugging to step over or step into the method. Doing to much in one step would also contradict another rule: the single responsibility principle.

<comment><USER2> A counterpoint is that more declarative code can often remove the need for tedious step by step debugging because the behavior of the code is more transparent. I do most of my work in Haskell and find I don't typically need to debug it like I would for a less declarative language because the meaning of the code is much more clear.

<comment><USER34> I come from a C# background and have little experience with Haskell, so YMMV. C# got many new features over the years like LINQ or Lambda Expressions. My experience is that you get most of them if used in a moderate way. Like splitting complex LINQ into smaller parts and introduce intermediate results instead of one big query. They are also easier to test this way. Another important aspect of this topic is if you are maintaining your own code or code others have written. I used to maintain code written by another team, which only did feature development and barely any code maintenance. While doing only code maintenance on code written by others for a longer period I gained a new perspective on what's good code in the long term.

</comment></comment></comment><comment><USER35> Call me old fashioned, but I remember when encapsulated was lauded as a good thing because it insulated the programmer from whatever programming model was considered popular this year was a virtue.

</comment><comment><USER36> I bet Fortran has an even lower 'proportional' variableness.

</comment><comment><USER37> Hey HN, I wrote this post. I'm getting the sense that not a lot of commenters are taking the time to read the contents before reacting to the title, so I'll share a little spoiler/TL;DR:

Good boilerplate is boilerplate that usually gets changed over time (and in different ways each time) as we iterate over the code.

It took me a while to come to this realization (and I explain the reasoning and consequences in the post), so I hope it's helpful to other people who might not have found this intuitively obvious.

Also perhaps "terse" or "clever" are not the best words to describe the counterpoint—I welcome edit suggestions.

<comment><USER38> _I 'm getting the sense that not a lot of commenters are taking the time to read the contents before reacting to the title_

As evidenced by none of the discussion hitherto noticing that your Python and Go examples actually perform a slightly different process? Was that deliberate? ;-)

(I rarely use Python and never Go; yet I noticed quite easily that the Python code is summing the selected _odd_ elements, while the Go code is summing the selected _even_ elements.)

<comment><USER39> > As evidenced by none of the discussion hitherto noticing that your Python > and Go examples actually perform a slightly different process? Was that > deliberate? ;-)

Good catch. I like abstract, declarative and structured code because if nothing else, it requires some level of engagement to write which has a side effect of reducing silly mistakes.

</comment></comment></comment><comment><USER40> I have no idea what the Go code does, but the python code is immediately clear. It reads like a line of English.

I can't see how anyone could prefer the Go version.

And I don't know if python allows this (it may not due to the significance of whitespace), but your proportionality problem can be easily resolved by placing each different clause on a different line, like this:

      sum((j if j % 2 else 0)
        for (j, k)
        in results
        if k)

<comment><USER41> this is what happens when people who "dont need math to program" write code.

if you want to sum over even numbers, just do:

sum([j*2 for j in range(0, end_range/2)])

and yes, brackets supercede pythons "whitespace is syntax". if you need linebreaks where, ordinarily, linebreaks are not allowed, just write brackets.

<comment><USER19> What the code in the article is doing is:

Given an iterable of pairs, sum the first elements of the pairs for which the first element of the pair is odd and the second element is truthy.

What the code you're suggesting does is, to be polite, unrelated.

<comment><USER41> and no sane person would write it that way. whatever it is that its trying to do.

i agree that i misinterpreted the codes intention.

</comment></comment></comment></comment><comment><USER42> I think most of the complaints about the python version go away when you do something like this....

        is_even = lambda n: n % 2 == 0
        score_result = lambda j, k: j
        is_interesting_result = lambda j, k: is_even(j) and k

        a = some_variable + 42
        b = sum(map(score_result, filter(is_interesting_result, results)))

or

        b = sum(j for (j, k) in results if is_even(j) and k)

List comprehensions only become difficult when you start doing conditional execution within the result side. Use if for filtering or turn your complex operation into a meaningfully named function/lambda expression.

<comment><USER43> The first one is horrible and super un-pythonic (it even violates PEP8[1]). But perhaps even more important, it doesn't even work since a map-function can only take one argument (not two).

Using functional programming paradigms like this often advised against in Python.

[1] [https://www.python.org/dev/peps/pep-0008/#programming- recomm...](https://www.python.org/dev/peps/pep-0008/#programming- recommendations) (search for "Always use a def statement")

<comment><USER42> > The first one is horrible and super un-pythonic (it even violates PEP8[1]).

I'm not really concerned with PEP. I'm concerned with if the idea being expressed is cleaner then the original. My first iteration was cleaner then the original comprehension (despite the comprehension being PEP8). It also let me see what I was really doing and I was able to turn my map and filter into a much nicer list comprehension.

Also, pointing out lambdas instead of defs is silly. It was done for an example. Most of the time you'll be operating on data structures with built in functions or supporting functions you will have written making it cleaner to use the map and filter paradigms.

        money = sum(user.get_payed_balance() for user in users if
                                               user.has_paid_bills() and
                                               user.is_still_subscribed())

bs

        clients = sum(map(User.get_payed_balance,
                      filter(User.is_still_subscribed,
                          filter(User.has_paied_bills, users))))

I much prefer the filters to the list comprehension in this case. I'll think "User's money for user in users if user has paid their bill and subscribed". I'm going to think "Sum the get_payed_balance for every user who is_still_subscribed and who has_paid_bills" for the functional implementation. If I had complex tuple arraignments then (like the OP's post) then I agree LCs will be the better way forward. If you're dealing with objects or functional- fitting problems I prefer map and filter.

> But perhaps even more important, it doesn't even work since a map-function > can only take one argument (not two).

The concept still stands. Just use `from itertools import starmap`. Starmap is like map that calls the * operator on arguments.

        >>> a = lambda a, b: 10
        >>> list(map(a, ((1, 2), (3, 4))))
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        TypeError: <lambda>() missing 1 required positional argument: 'b'
        >>> list(starmap(a, ((1, 2), (3, 4))))
        [10, 10]

> Using functional programming paradigms like this often advised against in > Python.

I'm not concerned with if it's "Advised against". I'm concerned with a) will someone be able to understand this better then the implementation that currently exists) and b) will I be able to come back in 10 years and tell what this is doing if need be.

You should check out this talk [1] before going around trying to use PEP8's inconsequential clauses to call something "horrible" code.

[1] - [https://www.youtube.com/watch?v=wf- BqAjZb8M](https://www.youtube.com/watch?v=wf-BqAjZb8M)

</comment></comment></comment><comment><USER44> Yes but it is avoidable if you use a Lisp. Every part of the code can be compacted into a smaller form. I know when I write in Clojure it's always the most concise code I've ever written, with minimal effort too.

<comment><USER45> This is true in Elixir as well, which has hygienic macros very much like a Lisp. There's a balance, of course, but it really is quite nice to be able to just rewrite the AST as you need. And one must always remember the adage data > functions > macros.

</comment></comment><comment><USER46> All of the examples are far better than the code I normally deal with.

That being said, the most tiresome code is this kind of step-by-step error checking.

      if (! is_numeric($id)) {
        exit('The ID is not a number.');
      }

      $db = open_database();
      if (! $db) {
         exit('There was an error connecting to the database.');
      }

      $query = db_query($db, 'select * from widgets where id = $1', $id);
      if (! $query) {
         $db_error = get_db_error_msg($db);
         exit('There was something wrong with the query: ' . $db_error);
      }

Zzzzzzz. It triples the code size. One third is the normal code path. Two thirds is all the error checking. I'm sorry, I just don't write it:

      $db = open_database();
      $query = db_query($db, 'select * from widgets where id = $1', $id);

I let errors bubble up to some general error handler, which stops the script in its tracks and gives the user a vague and unhelpful error message. It doesn't matter. Even if I gave them a very specific error message, all that they would do is log a ticket, and I would still go into the server log to uncover the line number the error was on, debug, and fix it.

Don't get me wrong. I write JavaScript to constrain user input, with friendly directions and error messages. And I set tight types in the database and add database constraints where I can. But I don't write all this step-by-step checking in the middle layer (PHP, Python, Go, what have you). So if the user somehow bypasses the JavaScript and tries to insert text into an integer column, the database will simply refuse, and the resulting web page will be a very ugly error message, which is what they deserve.

If the database is down, it's going to be ugly, regardless.

I admit that this strategy works okay for non-life-threatening, SQL-backed web apps and such. You may need to do something tighter in your work. But I wonder if there would still be something more elegant than the every-other-line error checking shown in the article.

<comment><USER38> _But I wonder if there would still be something more elegant than the every- other-line error checking shown in the article._

Factor out the error checking into a function:

        onerrexit(is_numeric($id), 'The ID is not a number.');
        onerrexit($db = open_database(), 'There was an error connecting to the database.');
        ...

I admit you still have to explicitly state you're checking, but that's not much overhead, makes the code somewhat clearer, and gets rid of all the if(...). If the error-action is more involved, like your "third paragraph", then you can make an errcheck that takes a function reference for the error- action instead (not sure if that's possible --- haven't used PHP in a long time --- but there's probably a similar method otherwise.)

<comment><USER39> Sometimes when I'm being very lazy writing C, I define a macro of this kind which doesn't even take any error message argument but just prints line number, textual representation of the code which failed and errno. Huge debugging aid at negligible cost.

<comment><USER46> Oh, well, Apache and PHP give me this out of the box. So even though there is not a great deal of custom error checking in my code as I said before, I always have enough information in Apache's logs to track down the problem. I guess with C and Go you have to roll your own.

</comment></comment></comment></comment><comment><USER47> It's always bad. The second line makes you understand with a glance what it does because it is declarative and explains _what_ is doing instead of _how_. The go code is awful (personal opinion, although I _hope_ it is widely accepted), much more verbose and it opens you up to a whole series of errors that are just impossible in the python version. Boilerplate code by definition is just duplication and it is always bad because opens you up to bugs in a specific part of the boilerplate while you can't have any bug at all in any boilerplate if you don't have any of it. Honestly I can't really see how anyone can prefer code that is more verbose and bug-prone to code that is more concise, clear and with less bugs.

<comment><USER38> _Honestly I can 't really see how anyone can prefer code that is more verbose and bug-prone to code that is more concise, clear and with less bugs._

I agree with you, but seeing the number of proponents of Enterprise Java there are, it's clear that there are a significant number of programmers who prefer verbosity and extra abstractions --- although IMHO not necessarily because it's actually better.

In fact a trend I'm seeing with a lot of programming languages is more verbosity and unnecessary abstraction, leading me to wonder whether programmers actually know the languages they're using or are barely scraping by with the very minimal basics (and in the case of some languages, a bit of OOP cargo-cult dogmatism.)

Although I'm not really familiar with Python, and the order of the clauses its conditional expression syntax is unusual and a little surprising, I think that second line probably took longer to write than it did for me to read.

<comment><USER48> > _I agree with you, but seeing the number of proponents of Enterprise Java > there are, it 's clear that there are a significant number of programmers > who prefer verbosity and extra abstractions --- although IMHO not > necessarily because it's actually better._

Even Enterprise Java wasn't verbose for the sake of it (I say "wasn't" because modern enterprise Java can be more like modern functional style than Go).

It was more verbose because it added tons of options and flexibility while keeping with the OO style, so everything was pluggable and configurable and factorable. But that's something else than Go style verbosity.

</comment></comment></comment><comment><USER48> > _In Python (and many other languages), it's very easy to unintentionally > hide tons of work in a single line of built-in syntax. Some lines do almost > no work, other lines do a moderate amount of work, other lines do what I'd > describe is tens of lines worth of work—a lot of work. It varies a lot, even > in beginner code. In Go, I've found that this variability is much more > diminished._

I call BS. Consider these 2 Go lines:

      heck_if_I_know_what_this_does()
      heck_if_I_know_what_this_does_either()

Just because Go has less powerful primitives, it doesn't mean that you don't use opaque code, libs, etc. all the time. Sure, you can look into what each function does -- but then again, you can also immediately tell that a list comprehension in python is doing at least O(N) work compared to a simple addition, without even having to open any other source file.

> _Is this good? I believe it is. I believe this code is more proportional to > the complexity of the work that it's doing._

We invented programming languages on top of machine code so that our code can be LESS proportional to the "complexity of the work that it's doing".

> _When reading proportional code, it's easier to notice where the interesting > bits are._

Not really. It's the inverse: the terse code only keeps the interesting bits. The "proportional code" gives you all the non-interesting, and getting in the way, mechanics.

> _When a friend was reading through the source code for ssh-chat, he was > surprised that I implemented my own Set type. I explained that while Go > doesn't have a built-in Set, it's just a few lines of boilerplate to make > your own on top of a map. In fact, I noticed that my version of Set evolved > to be fairly specific to how it was being used. In retrospect, I'm glad that > I was tweaking my own implementation iteratively rather than spending time > working around whichever limitations a generic library might have had._

Pray tell, what "limitations" a generic Set would have?

And why does those kinds of post remind one of Stockholm Syndrome?

<comment><USER49> > Just because Go has less powerful primitives, it doesn't mean that you don't > use opaque code, libs, etc. all the time.

True, but that's not what the article's arguing.

> We invented programming languages on top of machine code so that our code > can be LESS proportional to the "complexity of the work that it's doing".

No, we invented programming languages so that our code can be smaller and less arcane, not less proportional. The actual point of the article, which I believe you missed, is that if we focus on 'cleverly' compressing large amounts of logic into dense nuggets of code, it interferes with our ability to appropriately factor the code so that it produces the desired behaviour in the simplest and most readable way.

The article also states (and I agree) that if your code is wildly variable in the amount of semantic content per line of text, it's much harder to properly grok and (more importantly) to modify what's going on.

<comment><USER48> > _No, we invented programming languages so that our code can be smaller and > less arcane, not less proportional_

Smaller also means less proportional to the work that it's doing, since the abstraction, sugar and techniques we use to make code smaller do not yield the same compression ratio from the underlying instructions in all cases.

So, smaller = less proportional -- unless you suggest we should also strive to artificially constrain how succinct we make our code so that there's a constant ratio everywhere.

That is, so that 10 lines of code in a language always are (or at least, always strive to be) 10×n times of machine code. I don't see how that's feasible -- some abstraction could yield a 1/100 less code than machine code in one line, while another can yield a mere 1/5 or 1/10 less code.

But even if we could achieve that, I don't see it being even useful. Having higher level code strive to be more proportional to machine instructions is not necessarily telling us much about the cost of such code. It might tell us that it's complex and slower than another, but that doesn't mean much. It only matters what role it plays in the overall runtime of our program. Just because something A 5 times bigger than something else B, doesn't mean A needs more optimizing. A could be just fine as it is, e.g. if A is called rarely, and B is in some tight loop.

Gauging code by "code proportionality" (the only semi-legitimate use I could think of such a feature) is bogus. We should always profile.

> _The article also states (and I agree) that if your code is wildly variable > in the amount of semantic content per line of text, it 's much harder to > properly grok and (more importantly) to modify what's going on._

On the contrary. The part of "What's going on" that matters when it comes for modification is the high level stuff that goes on -- which a more terse code shows better, as it doesn't hide it with boilerplate.

In the end, that point seems both trivial and non-sensical: yes, boilerplate is easier to modify. That's because it doesn't matter much -- it's the stuff that you want to do that's hidden inside the boilerplate that matters.

e.g. I can write a loop to filter 100 numbers in tons of ways. And I can always modify it from one to one of the other ways.

But something like:

      value = filter(my_array, (val) => val > 5)

Just does what it says is does, and since it encapsulates the intention 100% there's no much room for wiggling.

<comment><USER49> In general, we're less concerned about "the work that it's doing" in the sense of raw processor instructions, and more concerned about the semantic complexity for the programmer. So if a line says "set A to true if B or C are true", that's simple. If it says "filter array A to only include elements where this inlined lambda function returns 5 or more, and then return the results with an even index" it's a bit harder to figure out the intent behind it.

<comment><USER48> > _If it says "filter array A to only include elements where this inlined > lambda function returns 5 or more, and then return the results with an even > index" it's a bit harder to figure out the intent behind it._

I'd argue the contrary though.

That the "semantic complexity" is less when you only keep intent-code, than when you spread it over 20 lines of boilerplate which you have to visually parse to get to the point.

Your examples are not analogous, because they do different things.

Let's make them implement the same example, Go/C/etc style and "terse" style:

      array_2 := make(int64, 0)
      over_five_index = 0
      for i, val := range(my_array) {
        if val >= 5 {
          over_five_index += 1
          if over_five_index % 2 == 0 {
            append(array_2, val)
          }
        }
      }

vs:

      array_2 = my_array
                  .filter((val) => val >= 5)
                  .filter((_, i) => i % 2 == 0)

I don't see how there's less "semantic complexity" in the former for the programmer to parse. It's just less _per line_ , but worse overall -- in that he has to now reconstruct the full intention from all the individual lines.

As for the first example, it would be:

      a = b || c

in both approaches.</comment></comment></comment></comment></comment>


Do I need to pay for Java now? - <AUTHOR> https://dev.karakun.com/java/2018/06/25/java-releases.html <comment><USER2> The conclusions that the article draws in "What does the new release train mean to my company?" are completely wrong.

Starting with Java 11, Oracle JDK is no longer free for commercial use, not even for a single day. However, as long as people are OK with GPL v2 + Classpath Exception (which is more permissive than it sounds) and don't need support from Oracle, they can just move to OpenJDK, which is built from the exact same codebase.

Shoutout to [https://adoptopenjdk.net](https://adoptopenjdk.net), which plans to ship LTS releases of OpenJDK. I believe this will be crucial for keeping the Java ecosystem healthy.

<comment><USER3> Does OpenJDK have the same optimizations as the official JDK? I thought OpenJDK doesn't have java's JIT...

<comment><USER4> Where did you get that idea? The differentiation between OpenJDK and Oracle JDK happens of course in the truly important part of the library: font rendering.

[https://technfun.wordpress.com/2013/01/18/last-difference- op...](https://technfun.wordpress.com/2013/01/18/last-difference-openjdk- oracle-jdk/)

<comment><USER2> That information is outdated. I'll say it once more: Oracle JDK 11 and OpenJDK 11 will be built from the exact same codebase.

[https://mjg123.github.io/2018/05/25/Opening-Oracle-JDK- Featu...](https://mjg123.github.io/2018/05/25/Opening-Oracle-JDK- Features.html)

<comment><USER5> From that article: "The JVM - This is where the majority of the OracleJDK-only features are. Oracle is open-sourcing a new GC, performance enhancements, tracing tools and a host of other changes."

If they open-source the performance of the JVM, they have nothing left to sell.

<comment><USER2> The quote describes the situation before JDK 11. As of 11, performance of Oracle JDK and OpenJDK will be exactly the same. They'll sell support and certified LTS builds.

<comment><USER5> Can you source that claim?

Also funny that they took the downloads offline today:

[https://docs.oracle.com/technetwork/java/javase/downloads/jd...](https://docs.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)

<comment><USER2> Apparently some links broke, but nothing was taken offline: [http://www.oracle.com/technetwork/java/javase/downloads/jdk8...](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)

> Can you source that claim?

From [https://www.azul.com/eliminating-java-update- confusion/](https://www.azul.com/eliminating-java-update-confusion/):

Oracle stated that their goal was to eliminate any functional differences between these two binaries. This will be complete with the release of JDK 11 in September. To achieve this goal, certain features (such as Flight Recorder and Mission Control) have been contributed to the OpenJDK project, whilst other features (like Java Web Start and JavaFX) are being removed from the Oracle JDK.

From [http://www.oracle.com/technetwork/java/javase/eol-135779.htm...](http://www.oracle.com/technetwork/java/javase/eol-135779.html):

As announced in September 2017, with the OracleJDK and builds of Oracle OpenJDK being interchangeable for releases of Java SE 11 and later, [...]

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER6> I wonder how this is going to play with JetBrains. If they're going to say F java and focus on a different direction. This is a pretty big deal moving forward. Seems like the community will now need to focus a lot of effort into the open jdk. This effectively happened with mysql & oracle. This company likes acquiring open source tech and then turning it into a commercial tech.

</comment><comment><USER7> Does anyone have an idea of whether C#/.NET are gaining ground on Java in the enterprise?

</comment><comment><USER5> Will you have to pay for the current Java 8u181 in prod?

I'm backing up the latest Java 8 for all platforms now.

Goodbye Oracle, Java 8 is the final Java, time to roll up the sleeves and build our own VM language!

<comment><USER2> You won't have to pay for using Oracle JDK 8u181 in prod, and you won't have to pay for using OpenJDK 11 and higher in prod.

You will have to pay for using Oracle JDK 11 and higher in prod, which is built from the exact same codebase as OpenJDK 11 but offers commercial support and long-term support (LTS) releases.

[https://adoptopenjdk.net](https://adoptopenjdk.net) plans to ship LTS releases of OpenJDK for free.

<comment><USER5> Ok, thanks!

But I'm pretty sure the superior performance of the closed source Oracle JVM will never be open-sourced.

It's the only value Oracle has left, and they know they cannot exploit it, even if this is a nice try.

Of the 2 million Java coders there are atleast 1% that care enough to look at building a 100% open-source VM language.

I hope James Gosling is building exactly that at Amazon.

<comment><USER2> As of 11, a "closed source Oracle JVM" won't exist anymore, and there won't be any performance difference between Oracle JDK and OpenJDK.

<comment><USER5> If so my guess is Oracle will be gone within 10 years.

</comment></comment></comment></comment></comment><comment><USER8> If openjdk doesn't make it's own JavaFX builds, it's time to move on to other languages, far better than Java on licensing base..

</comment><comment><USER9> TL;DR: Yes. You have to pay for Java now.

Quoting the article: «Oracle JDKs may only be used in production if you buy the commercial support.»

The alternative is using OpenJDK in production. We'll have to see how much the Oracle JDK and OpenJDK will diverge.

<comment><USER2> > TL;DR: Yes. You have to pay for Java now.

You have to pay for Oracle JDK but not for OpenJDK, which is just as good, except for a less business-friendly license, no commercial support, and no LTS builds straight from Oracle (instead you need to put your bets on adoptopenjdk.net).

> Quoting the article: «Oracle JDKs may only be used in production if you buy > the commercial support.»

Yes, but the author forgets about this in the "What does the new release train mean to my company?" section and draws completely wrong conclusions.

> The alternative is using OpenJDK in production. We'll have to see how much > the Oracle JDK and OpenJDK will diverge.

They will be identical. All of Oracle's JDK work, even LTS related work, will go into the OpenJDK repo.

<comment><USER4> How is a license that puts no restrictions on usage "less business-friendly"?

... Oh I see, Oracle's strategy here is to monetize GPL FUD.

<comment><USER2> > How is a license that puts no restrictions on usage "less business- > friendly"?

Use of GPL licensed software is heavily restricted in many corporations, whether or not it has the Classpath Exception. Among other things, it's hard to verify/enforce that projects only link against files that have the Classpath Exception.</comment></comment></comment></comment>


Ask HN:Can I start a company on an H1B visa? - <AUTHOR> <comment><USER2> It's unclear whether the OP is asking "Can I found a US company and then move to the US to work on that company via the company applying for an H1B visa for me?", or "Can I, currently in the US on an H1B visa, start a new company and work for it?". I suspect the answer to the latter question is "no". The rest of this comment assumes the former question.

As others here have said, an H1B visa requires demonstrating that the company could fire you, which isn't usually true if you own it. In the case of Rapportive, we had 3 cofounders, all needing visas; 3 turns out to be the perfect number for H1B purposes, because any two of you own enough of the company to fire the third. That sounds a bit circular, but made enough sense to USCIS that we got our visas, even though none of us was a US citizen. (Not that it was easy, but our difficulties were more about convincing them we were a real company.)

Of course, this isn't legal advice, and you'll want a good immigration lawyer who can prepare the petition appropriately for this arrangement.

</comment><comment><USER3> H1B -> Starting company -> Getting Funding -> Transferring Visa is not impossible but have lot of hurdles.

Irrespective of traction,you have to do following which is very frustrating & time consuming.

1\. Your company need to demonstrate ability to pay us "prevailing wages" as per SF standards [76k per year per person ] or Santa Clara [82 k per year person], office space and other general needs.

2\. You need to hire some one (contractor is okie ) US citizen/Green card holder to sign off on the H1 application. That person can be any non technical person .e.g. accounting or marketing to demonstrate employee employer relationship.

3\. You need to hire yourself as software developer demonstrating right skills and acting temp CEO /CTO . C position usually have higher salary ranges and have USCIS complications.

4.Form a board of directors who will have right to hire and fire you

Get lawyer who knows and have experience in immigration.

</comment><comment><USER4> Background: I've hired many many people on H1B and helped friends on visas start businesses.

TL;DR - In practice, this is very difficult to pull off. There are some chicken and egg issues that make it very difficult and the government is a pain in the ass about it too.

The rule of thumbs are that you cannot control the business that is giving you a visa (you can be fired from the job), the company has to demonstrate significant financial resources to employ you, and you have to do the transfer in a way that doesn't raise red flags with the government. Let's break these down.

1 - you cannot have a controlling interest in the business. This means you need a cofounder or cofounders so that your share of the business is less than 50%. Finding cofounders is tough. Especially cofounders who want to run the risk of you being deported during the next 4 years. Yes, there are ways to do it so that you own 49% and your cofounder owns 51%, but then you better be really sure that you want to give up board control and company control to this other person. This also means that your cofounder has to be a citizen or green card holder. Lots of constraints...

2 - financial resources either means you're putting up a million dollars of your own money or you've gotten an investor to give you $500k. But why is an investor going to give you $500k without a product or cofounder ready to go, and with a chance that you may run into visa issues and not be able to run the business? And therein is the chicken-and-egg situation. You can't stay without a financially sound company. But no one will give you money if you can't stay. So most people wait till they have a green card or build something on the side until they can get some traction or get some clients so they can show enough traction to raise funding.

3 - we almost got screwed with one of our employees at Spool because the government thought we didn't exist. Pre-launch we didn't have a website, our address was a UPS box, and though we were funded and clearly real, the USCIS basically rejected the visa transfer for one of our employees because they thought we were a shell company setup just for this guy to stay in the US without working.

Ultimately, there are people in an office at USCIS that make these decisions. These people will reject applications if something smells fishy, will reject it if they think this is a shell corporation just so you can stay in the US, or if they don't understand that startups get started and hire employees in month 1 of existence. Keep in mind that this transfer has to happen quickly. Your previous employer has something like 30 days to report that you don't work there any more. And your new employer gets to keep you in the country as long as the visa transfer is in process, but if you get rejected you're out of the country. So the transfer needs to happen quickly...and often your company just got started, has no other employees, has no website or product in the marketplace yet, and various other red flags as far as USCIS is concerned. The sequencing of all of these events in practice is difficult.

===== The best option ===== There are lots of "clever" options. I don't endorse any of them and you try them at your own risk. The safest option is to try and start something on the side, get enough traction to be able to pull together a seed round, and then have that new company sponsor your h1b. Lots of investors will give you money if you demonstrate the beginnings of a real business. This is extremely difficult though...you will basically need to work two full time jobs until you can raise a seed round.

I really wish it weren't this way but unfortunately the US government's rules were built in a manufacturing era and make no sense in our modern information age.

 __ _Disclaimer: This is not legal advice. Go talk to an immigration lawyer for real legal advice._ __

<comment><USER5> _The safest option is to try and start something on the side, get enough traction to be able to pull together a seed round, and then have that new company sponsor your h1b._

However, from what I heard - if you're on H1B you can only work for the company that sponsored your visa. So, the "best option" itself is pretty dicey.

<comment><USER4> Transferring an H1B to a company that the government thinks is legitimate is very straightforward. I was just hoping to outline the steps to getting a company considered legitimate. So if you can get your company off the ground and considered legitimate (the hard part) then you can have your visa transferred to that company (the easy part).

There are certainly employment contract issues -- moonlighting clauses, non- solicitation, and non-compete agreements. But those all apply to anyone building something on the side while employed full-time.

<comment><USER6> I think the point @karterk was trying to make is that it might be illegal for you to do any paid work at all at your own startup (or any other company other than your original employer), regardless of whether your original employer allows moonlighting or not. I'm not sure how H1B works in the U.S., but a lot of countries have rules like that attached to work visas. So until your visa has been transferred to your startup, your startup can't pay you any salary.

<comment><USER7> There are more ways to get paid by a company than by being a salaried employee. And some of them are even legal.

<comment><USER6> Yes, but being an early-stage startup would limit your options.

</comment></comment></comment></comment></comment></comment><comment><USER8> I have been in you shoes in the past (and left America due to frustration of the complexities of the process). Also, I am not a Lawyer - caveat emptor.

Short answer - get a US citizen to act as the Majority Partner in the business if at all possible. Do not accept even a cent from your new company if you go this route until it is set up and Generating Payroll. Once founded then transfer your H1 using your new company and then become employee/partner.

There are still ways around the stringent H1-B rules for employment that you can use to start a company in your name. However I must advise extreme caution in using any of them. The USCIS (citizenship and Immigration) might take a dim view of people who enter the US for a "Specialty Occupation" visa and then switch to founding companies.

I wish you the best of luck - it takes a lot of work to get a company going. Doing it while dealing with the complexities of the US Visa system is just adding to the mountain of difficulties you need to overcome.

If you do pull it off legally, maybe you can write a blog post that tackles this issue for other aspiring entrepreneurs who would love to tread in your path.

</comment><comment><AUTHOR> I am planning on starting a company with a partner who is a US citizen. I currently hold an H1B visa. Just wanted to know if people here have some pointers as to if this is even possible. I am going to be talking to an attorney but just wanted to get an idea before that. I have read about the startup visa act but it is still pending legislation.

<comment><USER9> Try operating from Vancouver, BC. There's a reason so many of your kind end up here.

<comment><USER10> "your kind" sure has a nuance in English that doesn't mean something good...

</comment></comment></comment><comment><USER11> As a rule of thumb if your company has an independent board that can fire you then it can sponsor your H1B. In practice this tends to mean you need to have investors owning a sizable share of the company.

</comment><comment><USER12> All wonderful advice and legally accurate. The best thing I can tell you is...start the business. If you have paying customers...everything else will fall into place automatically. Getting paying customers is the hardest part of starting any business. At worse, you will be able to run your company remotely from whatever country you are from. However, if your intent is to get the GC by way of starting a company, then there are lot of other easier options without suffering thru starting a company.

<comment><USER12> BTW, read this post...<http://nodemaker.posterous.com/the-problem-with-ideas>

</comment></comment><comment><USER13> Quick Answer: Yes, you can _start_ the company. BUT, you can't work for the company that company. Mostly, work = getting a salary.

If you are trying to start a company, feel free to incorporate it and own all of it. I would suggest worrying about getting paid once you have revenues coming in.

Then hire a good lawyer to figure out your options.

If you see huge growth getting paid should be easier with investors (IANAL). Alternatively, you can have it run on the side with the company collecting the revenue that you can eventually retire on.

</comment><comment><AUTHOR> Thanks for all the comments. Really helpful.Just to give some more background, I am currently working on an H1B and looking for ways with another partner who is a US Citizen. He would own a majority stake between 60%-70% and thus has the controlling stake.

</comment><comment><USER14> Yes (see @achival's post), but if you ever want to naturalize (get a green card), you'll have serious problems.

My father's in the process of working through the 'serious problems', please email me (in my profile) if you want more details.

</comment><comment><USER15> In my belief this could be tricky as I'm sure the H1B is actually tied to your current employer and would become invalid once you left that company.

I'm not sure however and I certainly wouldn't go off my word.

</comment><comment><USER16> Thank you for asking this question.

</comment><comment><USER17> You can own a business but you cannot work for it or collect a salary from it without having a H1 from that particular company. It's just like owning stock which is allowed under H1 but not working for any employer just like that without USCIS authorization.

The rules for your company employing you is that you should be firable by some other person or the board i.e someone has to have a control over you. You should not taking decisions about yourself.

<comment><AUTHOR> Does that work if I have the minority stake in the company and my partner owns the major chunk?

</comment></comment><comment><USER18> You can start one but can not work for one.</comment>


Show HN: Media Monitoring Tool with Traffic Estimation - <AUTHOR> Hi,
I'd like to share with you BETA version of our new media monitoring platform: http://www.boostthenews.com/
We've developed the tool that allows you not only to monitor online news by chosen keywords but also estimate traffic of selected articles and later on to promote them.
All ideas, questions, recommendations are more than welcome as we're still during the Beta phase and looking for early adopters.
You can easily leave your feedback here on our site (pricing section)
Hope you'll find the time to test it! <comment><USER2> I'm reluctant to provide a working email address in exchange for a "free beta" of a product that is vaguely described and depicted with a few screenshots. More than doubly so in the case of a PR firm.

In terms of a "Show HN" providing more information without requiring a sign up might alleviate my skepticism.

Good luck.

<comment><AUTHOR> Thanks for the feedback! We'll definitely work on providing more information and options for potential users!</comment></comment>


Hacking Firefox OS - <AUTHOR> https://hacks.mozilla.org/2012/11/hacking-firefox-os/

<comment><USER2> There are no phones available AFAIK yet. Only in development. You can emulate it. Which is not the easier from what i've tried

</comment><comment><USER3> Is there a Firefox phone available? And for how much?

<comment><AUTHOR> No, no phones for purchasing yet. They will, most likely, be available in the first half of next year. There are a few devices to test on for developers ([https://developer.mozilla.org/en- US/docs/Mozilla/Boot_to_Gec...](https://developer.mozilla.org/en- US/docs/Mozilla/Boot_to_Gecko/Firefox_OS_build_prerequisites?redirectlocale=en- US&redirectslug=Mozilla%2FBoot_to_Gecko%2FB2G_build_prerequisites)), but none are optimal for usage at this moment.

When it comes to testing, r2d2b2g ([https://hacks.mozilla.org/2012/10/r2d2b2g-an-experimental- pr...](https://hacks.mozilla.org/2012/10/r2d2b2g-an-experimental-prototype- firefox-os-test-environment/)) is the best option for now (and tomorrow we at Mozilla will talk more about its future on Mozilla Hacks).

<comment><USER4> I was under the impression that the Galaxy Nexus was better supported -- I just ordered a Nexus 4 and was hoping to flash Firefox OS onto my old Galaxy Nexus...

<comment><AUTHOR> It could work, but support for Nexus 4 would be very experimental. For that specific device, unless you really want an adventure, I'd recommend sticking to Android for now.

</comment></comment></comment></comment><comment><USER5> doesn't sound like "hacking" so much as "using"</comment>


The Ethical Dilemma Facing Silicon Valley's Next Generation - <AUTHOR> https://www.theringer.com/tech/2019/2/6/18212421/stanford-students-tech-backlash-silicon-valley-next-generation?src=longreads <comment><USER2> > "If you actually care about making communication technologies compatible > with democracy, then the place to be is at one of the companies that > actually has the problems," he says. "Not working at the big places that > could actually solve it does not make things better."

It would interesting to know how a Google employee would fair advocating for Google to pay more tax. Besides the China Search Engine thing it's what would make me most uncomfortable as an engineer there.

As it was recently said by Ritter Bregman, "taxes, taxes, taxes, and the rest is all bullshit in my opinion."

This article covers _a lot_ of ground, but basically no where does it mention the students grappling with the really big issues with big tech companies: antitrust and corporate taxes.</comment>


The Fraud and the Four-Hour Workweek - <AUTHOR> https://jacobinmag.com/2018/03/four-hour-workweek-tim-ferriss-work <comment><USER2> this article is a thin veneer of (fully justified) criticism of the get-rich- quick economy over tired old communist rhetoric. Please pick one or the other in future. I'd welcome more articles attacking this particular type of industry, but it's a big leap from "exploitation is bad" to "seize the means of production".

</comment><comment><USER3> At best this article smacks of resentment and envy at worst this article cites no facts or reputable opinion pieces and seems wishy-washy in making its point.

<comment><USER4> Agreed. The "point" i.e. last paragraph was less than climactic.</comment></comment>


Show HN: Eight-Bit Color Picker - <AUTHOR> http://bilalq.github.io/eight-bit-color-picker/

<comment><USER2> Unfortunately the colors of the web-safe color palette that we all know[1] (and hopefully hate) that results from combining 00, 33, 66, 99, CC and FF into triplet permutations has extremely poor color distribution.

Can you find any oranges in that color picker? Maybe 2. What about blues or reds? Pretty much the same. But you can find a ton of teals, purples, and pinks!

This is because producing naive permutations of fixed steps results mostly in muddy hue variance _between_ the primaries. This is not the natural way we see color variance. It results in far too many unique hues and not enough shades of the "good" hues ("red", "orange", "yellow", etc.). We only really distinguish between 7-15 hues at a basic level, but then we are used to seeing many shades of those same hues.

In addition, because the way the permutations are created it would be a ton of work to figure out how to sort them by hue. And if you did, you would notice just how many hues there are (way too many to care about having so many).

A much better color picker will take just a handful of hues (again, 7-15 or so) and then present varying shades (lighter, usually, but also darker for more variance) of them. Another crucial factor is to make sure the color picker includes a row for all shades from black to white (which at least this color picker has done).

For an example of a color picker that does this well with just a handful of colors, see the Google docs color picker.[2] You'll notice how much more pleasing it is to the eye.

[1]: [http://en.wikipedia.org/wiki/Web_colors#Web- safe_colors](http://en.wikipedia.org/wiki/Web_colors#Web-safe_colors)

[2]: [https://www.google.com/help/hc/images/docs/docs_1696586_colo...](https://www.google.com/help/hc/images/docs/docs_1696586_color_picker_en.gif)

<comment><AUTHOR> All excellent points! However, the default palette here is not based on the web safe colors, but on the colors from xterm-256color. More importantly, the palette is entirely customizable on a per instance basis of this picker. You can use this component to build something similar to the one from the Google docs picker just by passing in a string array of the palette.

My primary motivation for building this was to help applications that target CLIs. Things like colorscheme generators/editors for vim & emacs can benefit greatly from this.

</comment></comment><comment><USER3> What is this for? I'm not being snarky; I can't figure out what the use case is and I'm curious.

<comment><AUTHOR> While most applications these days can display millions of colors, many developers use one that is restricted to just 256 colors on a day to day basis: their terminal. (Yes, technically iTerm and and a few others can display millions of colors, but the $TERM cannot).

What's more, is that the palette for those colors tends to be different based on configurations in XResources and the like, so it needs to be able to support custom palettes.

I built this with the intention to use it as a component in my rewrite of Villustrator[1], a vim colorscheme generator. I'm going to rebuild it with CLI vim as its sole focus.

Of course, this can also be used for retro art web apps and the like.

[1]: [http://villustrator.com/](http://villustrator.com/)</comment></comment>


"KeeFarce" swipes encrypted credentials from password manager - <AUTHOR> http://arstechnica.com/security/2015/11/hacking-tool-swipes-encrypted-credentials-from-password-manager/ <comment><USER2> > Hackers and professional penetration testers can run it on computers that > they have already taken control of. When it runs on a computer where a > logged in user has the KeePass database unlocked, KeeFarce decrypts the > entire database and writes it to a file that the hacker can easily access.

 _slow clap_</comment>


Ask HN: How do extroverts cope with shelter-in-place due to Covid-19? - <AUTHOR> Do video calls, Netflix parties, and online games with friends help? <comment><USER2> One thing that really helped the extroverts on our team was a regular team- wide happy hour. We pulled 35-40 minutes on the calendar at the end of a day, everyone grabs a drink, and then we open the video chat and let people talk about anything and everything NOT related to work. By the end of it, everyone's a lot more relaxed, the tension seems a lot lower, and the extroverts are in much better shape. The introverts on the team are encouraged to attend; when I'm feeling more introvertish I'll leave my video feed off and hack a little bit while listening with my mic muted. :)

<comment><AUTHOR> Sounds like zoom happy hours is a thing. It takes BYOB to a new level

</comment></comment><comment><USER3> That's a good question. I'm introvert and realized how non-event it is for my working style.

Covid-19? Shelter-in-place? Cool. I been doing that before covid for last 4 yrs.

Sorry, not answering your Q :)

</comment><comment><USER4> I think they all call me to do 1 hour monologues.

<comment><AUTHOR> That's funny. Did you notice any changes in the things they want to talk about or is it the same?

<comment><USER4> It's mostly like a corona oral exam only without waiting for my answer.

</comment></comment></comment><comment><USER5> Don't know if I would call myself an extrovert, but we've enjoyed playing Jackbox Games ([https://jackboxgames.com/](https://jackboxgames.com/)) with audio or video chat. The nice thing is you already play it over your phone, so it's really just a regular video chat with one person also sharing their screen. It's also more social than a lot of games.

<comment><AUTHOR> Jackbox + Zoom calls sounds like a neat combo

<comment><USER5> It works pretty well!

<comment><USER6> We've done playOK.Com euchre with 16 people. We used jit.si foe the video chat.

Meet.jit.si/mainroomorsomething

For the main room

Then jitsi/room00 or /room01

So everyone just joins the main room and then joins a sub room for their table games.

Works pretty good.

</comment></comment></comment></comment><comment><USER7> It's definitely not the same, but it's not bad...especially given the times. My friends and I have been trying to do everything we normally do, just online instead. We have happy hours, play jackbox or games on tabletop simulator on zoom/discord (some games like codenames you can just screenshare and everyone doesn't need to own tabletop sim). We also like electronic music and used to go to shows/festivals together...and a lot of DJs have been doing live streams now, so we'll watch them together over Zoom and all dance on a video call.

<comment><AUTHOR> This made me smile. I pictured your guys streaming live music and dancing on a video call as a movie scene

</comment></comment><comment><USER8> I FaceTime my friends/family every night. We'll prop up our phones on our desks and eat dinner "together" or just mindlessly surf the web and share links to songs and videos. Sometimes we won't even talk at all if there's nothing to talk about, but it's still comforting having each other's presence on the phone. We'll chat if a topic of conversation comes up but it's nice not feeling pressured to talk as we carry on with our mundane tasks around the apartment.

</comment><comment><USER9> I'm scheduling video calls (FaceTime, Zoom, Jitsi) with everyone I know (family, friends, colleagues) on a cadence to make sure they're doing okay, give them a venue to vent or unload, etc.

<comment><AUTHOR> You're a nice human. I like this; will try to do the same

<comment><USER9> I appreciate you making the attempt. Thank you for the kind words.

</comment></comment></comment><comment><USER10> I post a lot of instagram stories and hope for friends to react haha. And also have been reacting to tens of stories of my friends. Also joining lives. Difficult times!

</comment><comment><USER11> Pretty simple. Make sure I am calling people everyday either on the phone or video calls. Talking to the neighbours at a distance always helps.

</comment><comment><USER12> If my friends are anything to go by, poorly.

<comment><AUTHOR> Might want to share some of the ideas in this thread with them!</comment></comment>


The Grind vs. The Pivot - <AUTHOR> http://avc.com/2014/12/the-grind-vs-the-pivot/

<comment><USER2> This just feels like an advertisement for Brewster.

<comment><USER3> I agree- this just reads like an ad. Wish there was a way to flag this as "reads like an ad", like they have on Wikipedia

<comment><USER4> As much as I like Fred Wilson, he occasionally does these native ad blog posts about companies in USV's portfolio and I have to admit it leaves a bad taste in my mouth. I don't doubt his sincerity; when it comes down to it, I think he's trying to help startups and entrepreneurs, and the best way he can do that is reference his portfolio companies...but ultimately "an experience that a company I'm intimately familiar with" winds up feeling like "I have a large audience of highly networked people reading my blog and I should leverage this to promote my investments."

<comment><USER5> I think you're confusing a venture capitalist with a journalist.

Venture capitalists are in the business of growing the value of their companies.

In this case, Fred did a great job of re-introducing me to one of his companies. I didn't understand why Brewster was important, but via his thoughtful post in which he shares personal experience, he's highlighted a pain point that I also share. I'll probably try the service now, and it may even make my life easier.

Most importantly, if Fred Wilson (or Mark Suster, or any other VC) only blogged about how great his companies are, nobody would read his blog. Instead, he built a loyal readership by writing on provocative topics, having an opinion, and starting conversations. His writing-to-promotion ratio is skewed very heavily in favor of writing.</comment></comment></comment></comment>


Did Network Solutions conspire in allowing coachtickets.com domain be stolen? - <AUTHOR> https://medium.com/@coachfairer/did-network-solutions-conspire-to-allow-our-domain-name-coachtickets-com-be-stolen-30892ca27380 <comment><AUTHOR> Epik.com the gaining registrar in this story seem to be the go to company for criminals online. See also: [https://www.legitscript.com/blog/2017/03/us- registrar-epik-p...](https://www.legitscript.com/blog/2017/03/us-registrar- epik-plays-dangerous-game/)</comment>