
The V Programming Language is open source - kgraves
https://github.com/vlang/v/commit/d32e538073e55c603992b5b65ebc837b01c28576
======
dang
This is a follow-up to
[https://news.ycombinator.com/item?id=20229632](https://news.ycombinator.com/item?id=20229632),
which explains why the submission links to a particular commit.

That discussion was one of the weirdest flamewars we've had on HN, complete
with an unseemly fight between programming language designers. If you're going
to comment in this one, please follow the guidelines
([https://news.ycombinator.com/newsguidelines.html](https://news.ycombinator.com/newsguidelines.html))
and take care not to repeat what happened there. Remain scrupulously
respectful, regardless of how wrong you think someone else is or of how you
feel about something. Then your points will be more convincing, and you'll be
helping to sustain the community rather than harming it.

------
estebank
In case the author ever reads this: assuming good faith, the _effort_ and
_intent_ is laudable, but you've put the cart in front of the horse by having
multiple amazing claims that would take many, many man/years to accomplish by
experienced developers, which is why they've been received with a lot of
skepticism. Even assuming a great level of skill, the claims a priori are hard
to take serious, even before taking into consideration the timeline. Now that
(part of?) the code has been released, it seems to be little more than a
transpiler from V to C, with allowed inlined C, with most advertised features
stubbed out. Had you been claiming "this is my target, very much in progress",
then the response to them would be less adversarial and more in the line of
"there are multiple reasons all of these targets are not necessarily
attainable simultaneously". Had you done that, your Patreon would also likely
not have a monthly ~1000 USD support either, which is a big part of why you
are in the receiving end of online backlash.

I want to imagine that you just got way over your head, underestimating the
effort needed to accomplish all of your goals, but at some point it takes a
bit of naiveté to think that well-funded teams in other languages haven't
tried to fulfill some of your goals before. I'm very much intrigued by the
"Space required/Build time" table, particularly how you think the comparison
makes sense or is fair in any way, as you're comparing compilers for
established languages with extensive standard libraries, implemented and
battle tested features and a decades of man/year effort to your solo project.

Looking at the project it is really hard to come away with an opinion that
isn't one of "this is a joke", "this is fraudulent" or "this is a well
intentioned inexperienced developer that has no idea how high the target
they've set for themselves is". I hope that if it is the latter.

~~~
dom96
> Now that (part of?) the code has been released, it seems to be little more
> than a transpiler from V to C, with allowed inlined C, with most advertised
> features stubbed out.

This is a little off-topic but I feel it needs to be discussed. The term
"transpiler" that you've used here is a little belittling, not only to V but
to other languages which are translated to C. I don't think its fair nor
accurate to characterize compilers which translate code to C as "transpilers".
It's valid when languages of the same level of abstraction are translated to
each other, but not when one language (C) is low-level and the other is high-
level.

All this being said though, V does seem to lean very heavily on inlined C
inside its standard library and compiler. So that assessment is totally fair.

~~~
ScottFree
> V does seem to lean very heavily on inlined C inside its standard library
> and compiler. So that assessment is totally fair.

If you don't mind me asking, how heavily did Nim rely on inlined C inside it's
standard library and compiler when it was only 3 months old? Or did you guys
do something different that early in it's development?

~~~
dom96
I wasn't around back then. But as far as I know there was never much inline C
used, many C functions were wrapped sure, but that's necessary to use
POSIX/WinAPIs.

Nim has always had a "everything should be implemented in pure Nim"
philosophy. So much so that the stdlib is even separated into "pure"
modules[1] (implemented in Nim completely) and "impure" modules (those that
depend on external C/C++ libs). Nowadays major things are implemented in Nim,
for example we don't use libuv/libevent but instead have written our own
epoll/kqueue/IOCP implementation.

1 - [https://github.com/nim-
lang/Nim/tree/devel/lib/pure](https://github.com/nim-
lang/Nim/tree/devel/lib/pure)

------
endymi0n
Despite the immense neophobia of Hacker News, I'll jump forward and say I
think there's a lot to love around vlang.

Go is an amazing language and my go-to language for most backend tasks these
days, but often when jumping back from Python, it feels needlessly cumbersome.

Now don't get me wrong, I'm not talking about any "magic", Go is exactly as
great as it is, because it's so simple and barebones. I'm talking about some
basic comfort that costs mental energy but zero complexity or execution speed.
The things the Rust community calls "zero cost abstractions". But the core
language developers seem to be pretty opinioated and _of course_ a set can be
logically thought as just a map of empty structs, so you don't need two
concepts in a language. But it's something I have to teach to every developer
starting out.

And although Rust gets a _lot_ of things right, it's too complex for my
choice. The performance/simplicity ratio of Go is just right, so that's what
makes me hopeful about V.

Vlang introduces so many concepts I just would have loved in Go. Native Enums.
Immutability by default. In operators. The list goes on and on and on.

At this point, it's absolutely overpromised and pretty much unusable without a
stdlib, an ecosystem and GC. But my best case scenario would be the
CoffeeScript case. A language that so beautifully covers another major
language's warts, that it drives the major improvements back to the origin.

Go 2 devs, please listen. 90% of the ideas in V are pure gold.

~~~
ilovecaching
That's the point of the project. It promises a very buzzwordy professional
grade language to rival other languages built by full time teams of engineers.
Of course it sounds like gold - unfortunately this is fools gold. We shouldn't
be promoting projects like this that are raking in more money than genuinely
useful in production open source projects by people who are too modest to hawk
Patreons.

I'm _all for toy projects and beginners writing their first langauge_. I
object to inflating a project well beyond what the author knows they can
deliver while collecting money from people who are hopeful that the project
isn't a joke. This is an example of how to take a passion project in the wrong
direction. Open source from the beginning, be open with your intentions, don't
over promise, don't accept money until you have something of value people can
use, don't flame people who are critiquing you when listening to advice could
make your project better.

------
tluyben2
I knew nothing about this project until I saw rants here and on reddit the
past week about it. I think many of us have been here; in my opinion (which is
just an opinion) this guy got in over his head like we all did when we had
limited experience in doing a particular project. I have often thought that I
could finish a momentum task in x weeks because in my head it really was a few
100 simple tasks and that was it. In reality ofcourse, it turns out to be a
1000 of simple and not so simple tasks, many of which actually were not very
simple. And more importantly; I had never done them before.

That is not malice, it is just inexperience and this guy really looks
inexperienced because he knew this would not hold up when he was pressured to
release the source. Keeping optimistic and thinking that he is further than he
is even though it is quite provable that he is not, is also a symptom of this
programmers disease.

It is related, I think, to the 80/20 rule which fresher programmers do not
even want to admit to; this is even more extreem as the 80% has not been
reached yet, but the author thinks he is actually past the 80%.

I could be wrong and it could be malice, but reading his responses and
everything I read the past days about this, I would say it's the same as what
I had when I was a teenager going with my father to where he worked and
claiming that there must be something wrong because why did it take so long to
program these computers while I could 'write code really fast'. 30 years later
I still can 'write code really fast' but I know that has not much to do with
finishing a project (in time or at all).

It is insane what he set out to do really; write a language to write a moving
project in, including docs and examples etc. For me, if he would've been more
realistic about the deliveries/timelines (just take a few years man!), I
would've actually sponsored him and if he turns out to not be a fraud I still
might. We have not so many people who dream big; we do need results though...

Edit: I described the Dunning-Kruger effect; forgot the name. I grew over it
by getting more experience (I got into some pretty hairy and complex projects
when I hit 18 and that taught me that reality really is very complex).

------
high_derivative
So without having followed the story, some thoughts on designing large
frameworks, where a programming language is possibly the among the most
ambitious because design choices are so consequential.

In my iterations of learning to do this (in the open source machine learning
space), there have been always five phases:

i) Ingest - use existing tools for years, try to build things and understand
the subtleties of their limitations.

ii) Build something - if you were right about the limitations and identify
ways to overcome them, people will recognize that and want to use what you
build.

iii) Maintain and learn how your assumptions live up to user realities.

iv) Realize very likely that your first attempt at greatness wasn't all that
yet, even if it becomes popular. Popularity is not a sign of what you building
being well designed, just that the need for it may be great.

v) Build something based on the combination of your initial hunches and taste
which got you into it to begin with, and your experience on building something
large.

Iterate, and given enough talent and sweat, you might create something that is
just right.

Being a computer scientist but not a programming language geek and looking at
this, the project looks like a first attempt at ii), but is selling itself as
a late iteration of v). Tech communities have very high standards and taste on
design, so overselling is deadly.

------
chubot
Hm I looked around the repo, and there doesn't seem to be much there.

    
    
        $ find . -name '*.v'|xargs wc -l|sort -n
        ...
          314 ./glm/glm.v
          330 ./time/time.v
          338 ./builtin/utf8.v
          339 ./examples/tetris/tetris.v
          490 ./os/os.v
          630 ./compiler/scanner.v
          644 ./compiler/table.v
          712 ./gg/gg.v
          814 ./builtin/string.v
          845 ./compiler/main.v
          848 ./compiler/fn.v
         3216 ./compiler/parser.v
        12573 total
    
    

I'm a big fan of compact code, i.e. doing more with less... but I have been
working on langauges for long enough to know that it takes surprisingly large
amounts of code to do anything useful in this space.

If you discount the lexer and parser, it's like 8-9K lines of code, and it's
hard to imagine much being done there. You can make a "toy" in that much code,
but the gap to a production compiler is very wide (e.g. a minimum of 50K or
100K lines of code).

There is also this translation which is not in the repo:

    
    
        $ wc -l v.c
        15099 v.c
    

\----

Also, this bootstrapping part looks pretty slick, except I get a core dump (on
Ubuntu 16.04 with default GCC):

    
    
        $ time cc -w -o vc v.c  
    
        real    0m0.553s
        user    0m0.517s
        sys     0m0.035s
    
        ~/git/languages/v/compiler$ time ./vc -o v .
        Segmentation fault (core dumped)
    
        real    0m0.095s
        user    0m0.002s
        sys     0m0.000s

~~~
cooperadymas
I can't understand criticising a brand new, v0.0.12 language built entirely by
one person of being too small...

~~~
reikonomusha
A lot of people have been finding the development of the project on a monthly
basis. The work that has actually been done might be unsettling to the
patrons.

~~~
ylluminate
As a patron of his work, I'm thrilled with what he's doing.

~~~
amedvednikov
Thanks for your support!

------
SolarNet
Coming from an outside reference frame (I have zero knowledge of the -
obviously contentious - backstory, and I am holding off on reading that
backstory until I review this language on it's merits).

On my examination it looks like a very interesting transpiler. I suspect that
like most languages it will bloat as it attempts to achieve it's goals,
especially with the size of the standard library that is going to be included
by implication.

However if it's goal was to be a useful C transpiler for the modern age I
would be more excited, and more interested. Things like hot reloading, easy to
use REST access, nice syntax, and the ability to fall back to C are all nice
features. For a certain class of application (notably the author's Volt
application, and video games) this would be very useful.

I would warn the author of throwing away what they have for going down the
rabbit hole of language implementation. It is nowhere as simple as they seem
to imagine. An anecdotal story, when using LLVM one will regularly come across
required parameters that seem like they should be optional and don't seem
important. And yet once one starts thinking about compatibility, errors, ABIs,
they realize there are hundreds of edgecases that must be accounted for. For
example structure returns on the windows ABI change the ordering of function
call arguments depending on the size of the structure, and additionally
require redundant memory operations (and failing to do both will cause your
compiler to work for some libraries but not others).

------
sesteel
If this project was trying to prove there is a space for a language with the
features as described, it was a success. Many people want a magical compiler
that has simple syntax, no calling overhead to C, and automatic memory
management without the overhead of a garbage collector, etc. I really feel
this is an indictment of both Rust, for its approachability, and Go, for its
lack of common features. I love and use both languages but it has been
difficult for me to get other developers to want to use either for anything
more than a utility.

~~~
lifthrasiir
There is a _problem_ space and a _solution_ space of programming languages. We
all love to have a language is performant and expressive and maintainable
simultaneously, and that is a problem description. We have no definitive
answer how to achieve that though. We haven't explicitly ruled out that it is
plain impossible, but it is evident that no single person is likely to deliver
such a language.

------
amedvednikov
Hello,

Developer here. The release was messed up by me having serious git troubles. I
had to destroy the repository twice, as the result and old README file with
the wrong instructions resulted in everyone having segfaults.

Everything will work as expected in a couple of days. Launching such a big
project for hundreds (thousands?) of testers is not easy.

~~~
faiface
So, what are the correct instructions?

I followed the instructions on the GitHub and yes, I'm getting segfaults.

~~~
amedvednikov
can you `wget [https://vlang.io/v.c`](https://vlang.io/v.c`) again?

~~~
faiface
Okay, I did and I was able to compile the `vc` compiler from the C source. The
REPL in `vc` seems to work (at least for the basic printing I tried) and
running `./vc -o v .` worked as well. But the new `v` compiler segfaults with:

    
    
      coudlnt create file "/var/tmp/vlang0.0.12//vrepl.v"
      Segmentation fault (core dumped)
    

EDIT: however, if I understand it correctly, it was not the instructions after
all, that resulted in everyone having segfaults...

EDIT2: okay, so I redownloaded the whole thing and yes, you fixed that now.
But it still segfaults sometimes. For example if I try to pass a `-h` flag.

~~~
amedvednikov
You had to do `git pull` to fix the "V" V binary :) Forgot to mention that,
sorry.

It's going to be much, much more stable in the coming days.

------
ksec
Maybe it would be better to change the link to [1] ?

[1] [https://github.com/vlang/v](https://github.com/vlang/v)

~~~
dang
Normally we would, but this case is a little subtler. The project had a big
thread a few days ago:
[https://news.ycombinator.com/item?id=20229632](https://news.ycombinator.com/item?id=20229632).
The issue arose there that the language was not open source yet. Submitting
this commit must be a response to that.

We mark follow-up posts as dupes unless they contain significant new
information
([https://hn.algolia.com/?query=by:dang%20significant%20new%20...](https://hn.algolia.com/?query=by:dang%20significant%20new%20information&sort=byDate&dateRange=all&type=comment&storyText=false&prefix=false&page=0)).
In this case, the significant new information is the open-sourcing, so I think
it makes sense to leave up.

~~~
ksec
Thanks. I wasn't aware of that thread. ( And I was wondering why about the
hostility towards it )

------
SwellJoe
It's pretty unclear what its purpose is. The examples look somewhat like go
(including something that looks like goroutines, right down to being called
with `go`). So, what differentiates V from go, I guess? (Or whatever other
language it views itself as competing with, if not go.)

~~~
ksec
Compared to Go, taken from [1]

V is very similar to Go, and these are the things it improves upon:

\- No global state

\- No null

\- No undefined values

\- No err != nil checks (replaced by option types)

\- Immutability by default

\- Only one declaration style (a := 0)

\- Much smaller runtime

\- Much smaller binaries (a simple web server written in V is 65 KB vs 7 MB in
Go)

\- Zero cost C interop

\- No GC

\- Much faster serialization using codegen and no reflection

\- Precompiled HTML templates unlike html/templates that have to be parsed on
every request

\- Fearless concurrency (no data race guarantee at compilation)

\- Enums

\- Generics (in July)

\- String interpolation: println('$foo: $bar.baz')

\- Stricter vfmt to ensure one coding style

\- Centralised package manager

[1] [https://vlang.io/compare](https://vlang.io/compare)

~~~
holy_city
Global state is a feature, not a bug. It's absolutely necessary for a number
of application domains and disallowing it by design makes the V language
totally unsuited for them

~~~
sagichmal
There is not a single situation where global variables are necessary.

~~~
crankylinuxuser
I take it you've _never_ programmed embedded?

Yeah, state sucks. But sometimes, you need a starting point, and diff from
that. And, that's state.

One of the safe ways of handling global vars, is by having only a single non-
interruptible function that can mutate global. And you have best make sure
your global-mutating function is __fast __. You don 't want to miss IRQs that
might fire off but are blocked.

~~~
sagichmal
Yes, embedded is enough of a special case that I don’t consider it as part of
a general purpose discussion on programming languages.

~~~
mises
Ericsson predicts 18 billion IoT devices by 2022. Those all need code written
for them. Do you still consider embedded programming a "niche"? Maybe it's one
specific case, but it's relevant and ought to be "part of the discussion".

[https://www.ericsson.com/en/mobility-report/internet-of-
thin...](https://www.ericsson.com/en/mobility-report/internet-of-things-
forecast)

------
13415
The name is good, the language has very cool features on the roadmap. I'd find
it interesting even if it was just a concept with no implementation at all, so
I don't get what people complain about it. Where do all these naysayers come
from? Do they hold personal grudges?

If it included an optional GC, version 1.0 of V would probably be my favorite
language and I'll definitely follow its future development.

------
phrmoy
Go V! (no pun intended).

------
FpUser
I did not have time to really look at it but if at some point they will
accomplish everything in their roadmap it will be one heck of a development
tool. Love it.

------
edgeyboy
After going through the source code, I can tell for sure that it's an insecure
C transpiler.

\- Most things call just out to C.

\- A lot of examples don't even compile.

\- Some things use CLI curl or mkdir, this is /INCREDIBLY/ insecure.

\- Many things are unimplemented.

\- Dev banned me off org when I opened issues about these and deleted issues.
I was unnecessarily rude on some which I apologize for, but deleting them and
calling me a troll was uncalled for.

I wrote about them here:
[https://twitter.com/boy_edgey/status/1142504580074344448](https://twitter.com/boy_edgey/status/1142504580074344448)
(thread)

~~~
tasty_freeze
I have to agree from the snippets of your reports, the tone of those reports
were needlessly antagonistic and superior.

Starting a report with "You idiot" or "Oh god this is a fucking goldmine"
should get you banned, even if the issue you are reporting is real. Such
reports aren't trying to contribute to the project; they are trying to boost
the reporter.

~~~
edgeyboy
I didn't ever say "Oh god this is a fucking goldmine". That was a reply.

------
trpc
It's amazing that one person can do all this. It really takes a huge amount of
dedication, knowledge and high IQ to invent a language from scratch alone. I
think he is trying to Rustify Golang which is a thing I always wanted to do
before giving up entirely on Golang.

~~~
hollerith
When I saw your "Rustify" I assumed V has a borrow checker, which it turns out
not to have.

Having immutable variables, no null type and option types is not enough to
make a language Rust-like IMO because dozens of languages have those things.

ADDED. Now that I know more, I see you have a point: V and Rust are the only 2
languages I know that have immutable variables, no null type, option types and
no automatic memory management (i.e., garbage collection):
[https://vlang.io/docs#memory](https://vlang.io/docs#memory)

~~~
amedvednikov
Yes, like [https://vlang.io/compare](https://vlang.io/compare) says, V is
somewhere in between Go and Rust.

------
AndyKelley
Dan, it seems like you're referring to me, and I don't appreciate this food
fight characterization. In society it is the duty of everyone to call out scam
artists to protect each other and that's exactly what happened in that thread.
At the time, it _was_ a scam, since the author was collecting money from
people on false claims. Respect is not only contained in tone of voice, but
also in how honest one chooses to be.

However, since then, two things have happened:

1\. The source has been provided.

2\. The website has been updated to note which features are unavailable.

So, this is now my position which I have stated elsewhere:

> Now that the website has the "WIP" label to communicate which features are
> not available, and the source is released, I no longer consider this project
> to be fraudulent. The information is available to everyone, and people who
> donate on Patreon are making an informed choice.

> I'm genuinely glad it turned out this way. Good luck on your endeavor, and
> welcome to the programming languages club.

~~~
amedvednikov
You called me a scam artist because in your opinion the compiler depends on
glfw and freetype :)

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

And then you proceeded spamming this on Twitter, GitHub, Hacker News, and
Reddit. Maybe even more platforms I didn't notice.

[https://github.com/vlang/v/issues/292#issuecomment-504281727](https://github.com/vlang/v/issues/292#issuecomment-504281727)

~~~
AndyKelley
Thank you for correcting that and the other 4 false claims I noted in that HN
comment. I'm glad you are no longer deceiving people about what V can do.

By the way, shelling out to curl and mkdir also counts as dependencies.

~~~
dang
> that and the other 4 false claims I noted

> I'm glad you are no longer deceiving people

This is a passive-aggressive way of continuing the same flamewar. Please stop.

------
withoutboats
It's pretty obvious that this person has essentially lied: they have not
implemented the complex features they claim while they hype benefits like
compile time and lack of non-zero cost features that will have to disappear
when they have implemented what they promised. But I think what's more
interesting, more telling, is the level of vitriol over 12k/year in patreon
subscriptions. Funding in open source is so absurdly unequal that people are
outraged over someone earning table scraps.

EDIT: No idea why this was flagged, I don't understand the norms of this
strange website.

~~~
staticassertion
The only thing developers seem to hate more than closed source software is a
funded open source project.

~~~
hutzlibu
Not in general, but many open source developers do hard work and do sometimes
not even get praise, so they don't like it when someone who they feel did not
work so hard or not at all and just promised unrealistic things, get's the
money.

(not judging about that case here)

~~~
staticassertion
This sounds to me like that same attitude that keeps people from saying how
much they make; that your coworker will get mad at you, and not your boss.

~~~
hutzlibu
A bit, yes. Except in cases where people make money from a limited avaiable
fund, by lying.

~~~
ScottFree
He hasn't lied about anything.

If you do a search in these comments for people who have actually given him
money, I think you'll find that none of us have done so under the pretense
that all the features he listed on the website are finished.

We're also not "buying" anything. We're supporting a developer who is writing
a language we would like to one day use. How else is it going to get written?
Do we expect somebody to toil away in obscurity for no pay for 5+ years first?

I would consider it money well spent even if he never finishes it. I'm voting
for the language I want with my wallet.

Yes, this opens me up to making me feel like a sucker if he is a scam artist.
But, he's delivered things in the past and he's delivered things even since
the last conversation. Most frauds don't ship.

~~~
esimov
It's not about founding or donation, it's all about false promises. How you
can give false assumptions about something which does not exists and it's not
provable. I'm thinking here about all the optimistic features the author is
acclaiming. As some of the commenters mentioned practically is impossible to
build a product (a new programming language) in solo and having only a couple
of thousands of LOC.

~~~
ScottFree
You need to stop. There are no false promises or false assumptions going on
here. If there were, then the negative coverage over the past three days would
include outrage from his patreon subscribers and his patreon donations would
have gone down considerably. Neither of these things have happened.

------
lkjasdfmls
I'm always excited to see updates on V

------
fogottenuser02
This was supposed to be originally posted on Dang's post. Evidently,
criticizing the mob-boss isn't allowed now.

AndyKelley never ever forget _why_ Ycombinator runs a "news" site.

YCombinator is a propaganda and VC funnel for upcoming projects that might
make them money. The convenient excuses of tone policing is to not scare away
upcoming companies and orgs that might be reprehensible to the public, but fit
into the idea of (0) Moloch.

The SEC only requires significant transparency to _Public_ corporations, which
YC doesn't primarily work with. So, they can be as opaque and 'fake news'-ish
as they wish. And they do, via "Hacker News". HN/dang _has_ removed and/or
modified and/of split off threads to lessen the impact of projects that affect
them. And my guess is that V is one of those projects that caught their eye.

Instead, you'll see dang and similar giving edicts from above dismissing and
ignoring legitimate complaints. Why? It all boils down to money. And YC wants
more. Is that really surprising?

Now, why aren't I posting under my usual username? Because bans, hellbans, and
other 'bad user' flags are a thing. And YC would never approach such
transparency. They won't even try for the GDPR, and that's saying something.

(0) [https://slatestarcodex.com/2014/07/30/meditations-on-
moloch/](https://slatestarcodex.com/2014/07/30/meditations-on-moloch/)

\-------------------------------------------

(My response, since you flagged it:

If we listened to anything you've taught us, you don't do something you're
good at for free.

So, why do you run a news site? It's certainly not out of the goodness of your
heart. My not-so-dark-idea is it benefits Ycombinator in a significant way. )

~~~
dang
I'd happily respond, but this comment is like a greased pig: there's nothing
to latch onto. Well, there's one thing: nothing about that project affects YC
or HN or us, and we haven't conspired to "lessen the impact". The sinister
specifics people come up with!

What catches my eye is flamewars on Hacker News, because part of being a
janitor is mopping those up. Our deep dark purpose? To have an internet forum
that doesn't suck. Unless you have plumbed my unconscious and know my thoughts
better than I do, that's all we're trying to achieve. That alone is plenty
valuable, so it's all we need to optimize for.

p.s. Nobody flagged your reply. It got caught in a software filter, and
moderators unkilled it, as we often do.

~~~
fogottenuser02
If we listened to anything you've taught us, you don't do something you're
good at for free.

So, why do you run a news site? It's certainly not out of the goodness of your
heart. My not-so-dark-idea is it benefits Ycombinator in a significant way.

~~~
dang
Of course! But the benefits aren't small and sneaky, they're large and open.
HN is valuable to YC simply by being an interesting place on the internet. The
most-interesting HN is the most valuable-to-YC HN, the one that is most in
YC's business interests. So curiosity is what we're optimizing for:

[https://hn.algolia.com/?query=by:dang%20yc%20valuable&sort=b...](https://hn.algolia.com/?query=by:dang%20yc%20valuable&sort=byDate&dateRange=all&type=comment&storyText=false&prefix=false&page=0)

[https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que...](https://hn.algolia.com/?dateRange=all&page=0&prefix=true&query=by%3Adang%20curiosity%20optimiz&sort=byDate&type=comment)

There's simplicity on the other side too: YC just optimizes for the number of
great startups it can fund. How optimizing HN (by keeping it interesting)
benefits YC (by helping it fund more great startups) is left as an exercise to
the reader [1].

The reason we don't mess around with local optimizations is that they're a bad
trade. What matters is the global optimization. Think of the goose that lays
the golden eggs. If you have the goose, why focus on an egg or two? Focus on
the goose.

[1] Actually I'd better not, or someone will make up something nefarious. The
reason is that some HN users end up founding YC-funded startups. And many are
startups that might not have gotten started otherwise.

------
mises
Wow, did dang really remove all the replies to his comment? Here's what it
looked like a few hours ago; it was still open in my browser.
[https://u.teknik.io/pD724.png](https://u.teknik.io/pD724.png)

Those comments were generally respectful; I saw no reason to remove them.
Seems over-zealous to get rid of any disagreement with a moderator's decision.

~~~
edflsafoiewq
No, the subthread was just detached and marked off topic. Scroll down a bit
more to find it:
[https://news.ycombinator.com/item?id=20251706](https://news.ycombinator.com/item?id=20251706).
This is a common moderator action on HN.

~~~
mises
Maybe it would be better for him to amend to his comment that "further
discussion on this comment has been moved to here:"

~~~
dang
We might eventually change the software to provide links to things like
previous children and previous parents, for those who like to follow these
things. But it isn't clear to me how to do it without complicating the UI,
which would be a cost that exceeds the benefit.

