Is that obvious? Yes, if I put on my cynical hat it pattern matches a money-grab or some other sort of fraud, but if I put on my charitable-interpretation hat V also perfectly pattern matches my idea of "solo developer wants to create the perfect language and goes after it with fresh eyes and a lot of enthusiasm (and yes, does get slowed down when it comes to fleshing out every little detail correctly and fully)". How do you distinguish?
It's especially prevalent in indie gaming and large Kickstarters. Some are actually scams, but a lot are just entirely out of their depth and realize this too late/only when their deadlines come due. And yet there are content creators which just make video after video just shitting on these people. Quiet sad all around.
(Though that link from the sister comment does make it look quiet bad in this case. Projects that just make great sounding claims about the current state of the project, even though none of it is true can't be taken seriously in my opinion.)
In the case of V it's not only about details. Memory management, for example, is a fundamental part of a programming language and not something you can do as an afterthought. It is still not clear at all how memory management works in V.
Note- just by being a strong Go alternative by itself, one can see possible "behind the scenes" conflicts and motives. Though both V and Odin really should be fully embraced, because they continue the direction and changes in thinking started by Go, while providing features that such users might crave or have wanted.
V has been more successful than other newer programming languages at getting sponsors and supporters (check V's GitHub or vlang.io), to include publicity, both very good and at times negative (which appears to include angry detractors). It also has been developing at a more rapid pace than other languages in its category.
From looking at the history, some of the controversy appears to come from years ago and whether or not the language was real or was going to be released, because it was already "advertising" itself and had sponsors. Keep in mind that other languages have a very hard time at getting sponsors, supporters, or users. So, that another language getting what they are not able to or feel they deserve, can become a source of conflict as well.
My opinion is that the V creator did nothing wrong, because it was a very smart decision to attract sponsors and users, and the creator did release the language. This alone already separated V from the many languages we never know or hear about, the ability to get enough sponsors and supporters to sustain growth and momentum.
Yeah, it's might seem great to be a solo developer making what he/she feels is the perfect language as a hobby, but at some point the enthusiasm stops or the person realizes what's the point if nobody cares and nobody uses it.
Another aspect of this situation is it appears detractors were running with the narrative that V was "fake" or "vaporware", and then when it was actually released, they had to reset their narratives. You can't claim that something that exists and is used by many, is "fake" or non-existent. So then the attacks appear to then go for whatever might stick. Anything about the language, which is "not perfect" or as they feel is claimed, is then targeted. This is why we have these odd and controversial takedown attempts of a language which is still in alpha and evolving. I'm very much not saying that people shouldn't be criticizing or pointing out flaws, but rather it doesn't need the viciousness or underhandedness of trying to persuade people to stop using or attempts to kill it off.
Ultimately, just don't think that such tactics are going to work, because V has such strong community support and is continually improving. V is well on the path of becoming a very viable and highly useful language.
When it comes to sponsors and donations, V is far (really far) from the best in the category. Not to mention that Zig has a proper non-profit foundation, which is a far greater achievement than GitHub stars or even sponsors.
All your comments in this thread are in disagreement with reality to the same absurdist degree of conspiracy theories. And of course you yourself can't help but point out that everything is a conspiracy against V, which is laughable.
And it's laughable to claim that its popularity on launch was due to false advertising. Even your leader admitted that self hosting on launch is impressive:
> Wow, that's incredibly fast. Self-hosted in 2 weeks? Hot code reloading? This is everything I plan to do with Zig, but apparently done already. How did you do it so quickly?
(I hope you won't argue that V wasn't written in V on release.)
Funny how the agenda changed.
If anything, I suppose the urge was too great, to not expose yourself.
I totally agree with kristoff here and also munificent[1]. Y'all have a massive victim complex on grand display in this thread and exhibit the classical signs of projecting your own issues on to everyone else.
The "projection", is coming from yourself. That you are a supporter of Zig and Rust, is your own business, that's not the focus of this thread or what my comments are about. But clearly you couldn't help yourself to come do some bashing of a rival language, then gaslight about why there might be a reaction to it.
Unfortunately it’s very hard to convince self-proclaimed victims that they are not in fact victims, because then you become one of the “detractors” or “competitors” looking to “gaslight” and “slander”.
I’ve never seen a language with so much self-inflicted drama around it.
And there is more:
1) The OP does not mention he is evaluating an alpha version of the language.
2) OP starts the "evaluation" with a link to a very contentious and controversial post from 2019, which smears the author and describes the language as vaporware (despite it being 2022 now and over 100 releases later).
3) At no time during the creation of his supposedly month long "evaluation" did the OP reach out to the V developers or community to verify anything in his report.
4) At no time did the OP demonstrate any good will by filing any bug reports or creating a discussion at V's GitHub. He had a unknown throwaway GitHub account, to easily do such.
5) The OP's "evaluation" summary (that can not be responded to) is full of opinions that are subject to interpretation.
6) Exactly how qualified is this mystery evaluator doing this negative review? Unknown.
7) Multiple times in the review, the OP mentions "we", as if he is part of a team. Who is "we"? Unknown.
8) The OP avoids attempts to be engaged in debate with V developers on various points about his review or make it known that he will modify it for correctness, fairness, or language version.
The irony of you picking apart the OP's wording as not being exactly correct is just too much. There's the projection I was talking about. :-)
> Multiple times in the review, the OP mentions "we", as if he is part of a team. Who is "we"? Unknown.
On the off chance that you just aren't aware of the idiom, it's common to say "we" as in "me and you, the reader."
Search for "we" in one of my pieces of writing, for example: https://blog.burntsushi.net/csv/
There's nothing nefarious about it. See also: https://academia.stackexchange.com/questions/5500/use-of-fir...
They were not "clean sheet, let's make a great new language" implementations.
What you should do now is to decide what to do with those points instead of arguing. If the decision is WONTFIX (okay to do, not everything can be made into the language) then the advertisement should be updated (ProTip: you should really have done this years ago). If the decision is to do something with that then the advertisement should be still updated, hopefully with a link to the tracking issue. If you are already doing something about that then you still should have a link to the tracking issue. If the point is "misleading", then you should write out clearly why it's misleading, how the author could have concluded in that way (i.e. assume no malice and debug instead), and how to verify your updated claim. With no strings attached.
Honestly though these points have been iterated and reiterated years ago. I had a hope that you have learned (hard) from that past experience; my hope seems not justified.
Like the language compiling itself in <1s? It's true and you can verify it yourself:
And you are slightly altering the very claim you've already said; the OP specificially tests the claim that "V compiles [...] ~1 million (x86 and tcc backends) lines of code per second per CPU core", which I can easily verify on my machine (1m_helloworld.v took 25.5 and 15.5 seconds to compile under the same settings). To be fair these test files are edge cases you can easily dismiss (ProTip: you can make your advertisements more accurate), but edge cases show the weakness of your design and you should not confront them.
> extraordinary claims failed V.
I asked you to list such claims. You fail to do so.
There's no way it takes 15s to compile 1m_helloworld.v. You're probably using a debug build of V.
What's your hardware? CPU/SSD.
You don't have to guess because I can give you my log. I have exactly followed what the OP did, except for more recent revision because I couldn't get it compiled in my environment.
$ git clone https://github.com/vlang/v/
$ cd v
$ git checkout 0e4198f23b2b9a52d72f61dd40d019412b809791
$ VFLAGS="-prod" make
make fresh_vc
make[1]: Entering directory '/tmp/v'
rm -rf ./vc
git clone --depth 1 --quiet --single-branch https://github.com/vlang/vc ./vc
make[1]: Leaving directory '/tmp/v'
cd ./vc && git clean -xf && git pull --quiet
make fresh_tcc
make[1]: Entering directory '/tmp/v'
rm -rf ./thirdparty/tcc
git clone --depth 1 --quiet --single-branch --branch thirdparty-linux-amd64 https://github.com/vlang/tccbin ./thirdparty/tcc
make[2]: Entering directory '/tmp/v'
make[2]: Leaving directory '/tmp/v'
make[1]: Leaving directory '/tmp/v'
cd ./thirdparty/tcc && git clean -xf && git pull --quiet
cc -std=gnu99 -w -o v1.exe ./vc/v.c -lm -lpthread
./v1.exe -no-parallel -o v2.exe -prod cmd/v
./v2.exe -o ./v -prod cmd/v
rm -rf v1.exe v2.exe
Note: building an optimized binary takes much longer. It shouldn't be used with `v run`.
Use `v run` without optimization, or build an optimized binary with -prod first, then run it separately.
Note: `tcc` was not used, so unless you install it yourself, your backend
C compiler will be `cc`, which is usually either `clang`, `gcc` or `msvc`.
These C compilers, are several times slower at compiling C source code,
compared to `tcc`. They do produce more optimised executables, but that
is done at the cost of compilation speed.
V has been successfully built
V 0.2.4 0e4198f
$ cat > t.sh && chmod a+x t.sh && ./t.sh > 1m_helloworld.v
#!/bin/bash
echo 'fn main() {'
for i in {3..1000000}
do
echo ' println("hello world")'
done
echo '}'
$ time ./v 1m_helloworld.v
parsed 100000 statements so far from fn main.main ...
parsed 200000 statements so far from fn main.main ...
parsed 300000 statements so far from fn main.main ...
parsed 400000 statements so far from fn main.main ...
parsed 500000 statements so far from fn main.main ...
parsed 600000 statements so far from fn main.main ...
parsed 700000 statements so far from fn main.main ...
parsed 800000 statements so far from fn main.main ...
parsed 900000 statements so far from fn main.main ...
real 0m14.929s
user 0m6.516s
sys 0m8.031s
I have also verified that TCC was indeed in use: $ mv thirdparty/tcc/tcc.exe thirdparty/tcc/tcc.exe.orig
$ time ./v 1m_helloworld.v
parsed 100000 statements so far from fn main.main ...
parsed 200000 statements so far from fn main.main ...
parsed 300000 statements so far from fn main.main ...
parsed 400000 statements so far from fn main.main ...
parsed 500000 statements so far from fn main.main ...
parsed 600000 statements so far from fn main.main ...
parsed 700000 statements so far from fn main.main ...
parsed 800000 statements so far from fn main.main ...
parsed 900000 statements so far from fn main.main ...
==================
cc: internal compiler error: Killed (program cc1)
Please submit a full bug report,
with preprocessed source if appropriate.
See <file:///usr/share/doc/gcc-7/README.Bugs> for instructions.
...
==================
(Use `v -cg` to print the entire error message)
builder error:
==================
C error. This should never happen.
This is a compiler bug, please report it using `v bug file.v`.
https://github.com/vlang/v/issues/new/choose
You can also use #help on Discord: https://discord.gg/vlang
real 6m50.090s
user 6m8.375s
sys 0m31.094s
(I gave up when the gcc memory usage ballooned up to 20 GB.)> What's your hardware? CPU/SSD.
i7-7700 3.60 GHz, 48 GB of RAM, SSD in use, Windows 10 WSL (that's probably why kernel time is higher than average, otherwise my userland time agrees with the OP).
It says
Note: `tcc` was not used, so unless you install it yourself, your backend C compiler will be `cc`, which is usually either `clang`, `gcc` or `msvc`.
Also you have "gcc" in your error:
See <file:///usr/share/doc/gcc-7/README.Bugs>
And on the website the claim is made for tcc and x64 backends.
Like I said, no way it'd take 15 seconds :)
I think it's pretty clear.
Anyway, now that we are clear on the compilation speed claim, can you please list a couple of those extraordinary claims?
(This is my final response on this matter. I have already given enough information and an inability to interpret it is not my business.)
I've just tested it, and turns out all C compilers are terrible at hundreds of thousands of print calls (for me Clang was stuck for minutes with 100% cpu usage).
The claim was made about actual code, like the V compiler itself, which is about 220k loc and compiles in 0.3 seconds, not some unrealistic test with a million of prints.
I'll make it clear on the home page with a link to the benchmark.
The impression should not be given that V is just a one-man show. Many of the offshoot projects are in collaboration with others, not just the author, who have invested heavily in them and also wanted or helped create them.
V's author is paying others to write things in V (even when basic functionalities don't work as advertised). They don't want to improve the language, they want to create a showcase to attract more funding, that's about it.
As far as I'm concerned, V works as described in their documentation. As with any language, there are some specifics that are subject to interpretation or debate, but that is to be expected.
And, V is not doing anything that other languages also try to do in terms of sponsors and investors to sustain progress, increase popularity, or make improvements.
Really? Can you explain to me how memory management works in V?
Autofree will not be the default until version 0.3 of the language. Autofree inserts free calls during compilation, and the rest is managed by RC. V will be giving users 3 choices: GC, Autofree, or manual. Those people that actually use the language, would already know this.
This is mentioned on both the website and in the documentation, and any confused users can simply ask on discord (https://discord.com/invite/vlang) or the GitHub discussion (https://github.com/vlang/v/discussions).
EDIT:
> which works, but you have to know what you are doing
This does not feel very convincing...
Aren't you the part of the core team who bans anyone on discord who asks questions about V's memory management?
I tried V when it first got popular (about 3 years ago). I am no expert on languages but the way it was ductaped (AST-less compiler for "performance", a "graphic library" when even basic things don't work etc etc) made me eventually lose interest.
3 years later V is still mostly where I left it. If the V author focused on the stabilizing the compiler instead of starting off shoot projects like vui, vdb etc. it might actually work.