Hacker News new | past | comments | ask | show | jobs | submit login
V Programming Language released (vlang.io)
146 points by _ieq6 on June 20, 2019 | hide | past | favorite | 121 comments



Let's not consider it released until the source is released. So much confusion surrounding this language.

Edit: The author has redacted the binary release and says will release the binaries with the source on July 22nd [1], thus, this post is invalid at this point as nothing is released.

[1] https://twitter.com/v_language/status/1141625734953390081


I find these languages that are developed behind closed doors and have no source published a bit frustrating. Even more so when they make big promises.

Just like you can no longer charge for compiler, I don't think it's possible in the future to not publish the source. The truth is, there are plenty of actual open source alternatives to C (zig, et al.), what makes some shadowy language a reasonable alternative?


99% of new programming languages are "someone thought it would be fun to make a new programming language" with no real effort to make it genuinely useful and good for real world use


99% of percent of the new programming languages are nothing more than a syntactic sugar over an existing language, and 99% percent of their developers are developing without any real use case and. I suppose they are made only to collect some money (by donations eventually). As they are developed they are immediately forgotten.


Not published yet. Perhaps the author considers publishing prematurely to be more hassle than its worth?


If it's the intention, the author surely has been misguided. A drama is already happening (for example, [1]). While I think it is technically possible to deliver all of them (it should be noted that it is not exactly an optimizing compiler, which makes many things easier), it is natural and understandable that people doubt its premise before the full release.

[1] https://github.com/vlang/v/issues/35


I'd hardly call it a drama. Claims like it's not possible to build features without AST or codegen json decoders are just ridiculous.


That is not what I stated in the issue.

For the kind of features that you wanted in your language, not just generics, requires a form of AST (abstract syntax tree), and if you language does not have an AST, which is technically possible, then you cannot have a lot of the features you have been advertising.


I should stress that that is also your misconception. For example, you can implement generics without an AST if you don't care about performance; codegen can either output a single binary mandatorily requiring a sort of vtable (therefore every parametric code will be indirected), or output a partial binary with holes where holes will be patched later (much faster but disallows optimization across hole boundaries).

You should have framed your question as follows: those features can be implemented without an AST, but an AST is a standard and reasonable way to do them and not using an AST would require a strong rationale. So what's that rationale? (And amedvednikov, this is my question for you.)


No you don't understand :) It's IMPOSSIBLE without AST. The Odin creator says so. That's why I'm a liar.

V simply generates functions for every type they're used with.


> V simply generates functions for every type it's used with.

So you have a "template" function as written in the source code and a list of actual functions generated. You can either generate them as a final step or on the fly as you encounter; in either ways you probably have a mapping from the function name to the function body or something similar. How is that stored?


But producing a flashy website is not?


While it looks nice, it brags about it's compilation speed while simultaneously not offering any optimizations. If you want to have optimizations, C/C++ source-to-source compilation is required, which is slower by factor of 10. After that, a traditional C/C++ compiler runs the compilation/optimization, which again, costs time. What use is fast a compilation, if the resulting program can be slower by orders of magnitude?

Other than that, the design of the language looks nice and I will give it a spin at some point. Maybe I'll convert some HPC benchmarks to V and see how they perform.


This is the same approach that the language Jai (which Jonathan Blow is developing) is using: Fast-to-compile debug builds via hand-written x64 compiler, heavily optimized release builds via LLVM. This is why he was able to have ridiculously high-speed debug builds, and I think V is probably the same right now.

I think J. Blow commented in one of his videos that he might be able to put some optimization on the x64 compiler (such as dataflow optimization) when the language is mostly complete. Although builds will be slower because of this, I still trust Blow that he will make a faster compiler than GCC/Clang, because the compiler will be specialized to its language rather than being all-purpose. (Also, C++ takes ridiculously lot to just parse everything, while Jai is must simpler to parse). Maybe V's developer will also work on some optimizations after the basic compiler's finished.


You can build and test faster using the direct to machine code compiler, then use the C compiler for a final production test and distribution.


You are right in a scenario where testing is lightweight and quick. I'm sure this can cover a lot of use cases. However, If the testing/development itself involves heavy computation (large integration tests for example), there are diminishing return from quick but unoptimized compilation.


I generally agree with what you’re saying in terms of perf comparisons, but high performance debug builds are incredibly important.

On the other hand, the reason they tend to be slow in large c/c++ programs is the module model basically meaning “behold as every file in your project parses and interprets large portions of the host platform’s standard library”. All modern languages know to avoid that - honestly if you want masochism I’d be curious to compare the time-to-execute for modern js engines, simply because they have incredibly large amounts of pressure to get to running code as fast as possible.


What happened to releasing the source code today? https://twitter.com/v_language/status/1137750611389288450


https://github.com/vlang/v says the source code will be released on 2019-06-22.


Hmm, autor promised he use some simple range/lifetime analysis for semi-auto memory management. But seems it's not true: https://twitter.com/8vit_devel/status/1141573808320647168


I don't really get excited by new languages but I must say I really like what I'm seeing here going through the docs. This is what I wanted nim to be, but with the safety.

The standard library and package manager + packages will make or break V.

[edit] ow, not open source yet.


The safety? What safety does V offer that Nim doesn't?


Probably vaporware


Nim is safe enough.


The too good to be true alarm bells in my head are ringing. There's almost no way it delivers on all of the features listed here. Gonna need a lot of proof to back all of this up.


It's a scam. You can promise bells and whistles as many as you want but you have to prove it.


This guy is a complete fraud. He's collecting $927/month on Patreon by deceiving generous and hopeful programmers. The claims on the web page are outright lies.

----

README.txt: Right now there are several dependencies that you need to install: clang, glfw, freetype, libcurl.

web page claim: 400 KB compiler with zero dependencies

README.txt: Missing features that will be available soon: x64 machine code generation without a C compiler

web page claim: V compiles ≈1.2 million lines of code per second per CPU core. (Intel i5-7500 @ 3.40GHz, SM0256L SSD, no optimization). Such speed is achieved by direct machine code generation and a strong modularity.

README.txt: Missing features that will be available soon: hot code reloading

web page claim: Hot code reloading. Get your changes instantly without recompiling.

README.txt: Missing features that will be available soon: REPL

web page claim: V has a REPL

README.txt: Missing features that will be available soon: cross compiling

web page claim: Easy cross compilation. To cross compile your software simply run v -os windows . or v -os linux . No extra steps required, even for GUI and graphical apps!

---

Furthermore it's really shady to release only closed source builds 2 days before a source release. Why the sudden change of mind? https://twitter.com/v_language/status/1137750611389288450

There's evidence that this person cannot be trusted: https://github.com/voltapp/volt/issues/143 Some quotes from that issue: "Do you go read firefox history?" "Yea, this is really unnerving. I feel like I need to invalidate all my firefox sessions now. What did you do?" "Lol that's what you guys get for running proprietary software."

More evidence of false claims: https://github.com/vlang/v/issues/35

I'm all on board with friendly competition, but this is pretty hostile behavior to the open-source community. Be honest about what your software can and cannot do. And release source or GTFO.


Wow, calling me a fraud and a scam artist based on these "facts"?..

The compiler has ZERO dependencies, as stated on the website. You can build it with `clang v.c`.

Do you really think the compiler needs glfw or freetype to function? It's for the graphics library to build things like the tetris.v example.

As for clang, It was made very clear that V compiles to C in addition to emitting native code, and that it's much more stable at the moment.

Hot code reloading will be available on June 22.

Cross compiling already works, and you saw this on twitter. How can you claim it's a lie? https://twitter.com/v_language/status/1137537130887077890


> Hot code reloading will be available on June 22.

What the heck, so you have claimed that it's just a readme or source cleanup but that was actually a huge missing feature. You said that you have high standards [1], but you don't seem to have high standards on what you say.

[1] https://blog.vlang.io/post/13/Why-isn't-everything-already-o...


You need to detect sarcasm. Did you think I was serious when I said I was delaying by 2 days to clean up readme?


If you weren't serious at that time it'd be a bigger problem.


You remind me of another russian school kid "inventor" that "created" completely new OS named "BolgenOS" :D Basically reskinned Ubuntu and tried to present it as 100% original software.


> Do you really think the compiler needs glfw or freetype to function? It's for the graphics library to build things like the tetris.v example.

Do you ship the compiler with those libraries that require those packages? If yes, then the compiler is not 400kb. The compiler nowadays never means only the compiler executable, it means the complete environment it ships with.


The V compiler is the program that builds source in V. It has zero dependencies, and that's the claim.

The modules can have gigabytes of dependencies, this doesn't make the compiler depend on them.


[flagged]


Where am I subtracting it?


Yeah you don't. You never added the size of the dependencies (like clang) to the size of the compiler.

And thats what I am saying. You don't even need to add the size of your stdlib. A compiler does not include the stdlib as per your definition . So your compiler is actually much less than 400kb.


Please list these "dependencies" other than the C compiler that's needed to bootstrap the language anyway. I'll wait.


> other than the C compiler

On windows, clang is about 100 mb download and it further requires msvc install which is around 1 gb download if you only download the build tools.

That in itself is a fucking 1.1 gb dependency.


I originally did not call this project as fraudulent rather "This is not as advertised" which talked about here: https://github.com/vlang/v/issues/35

Note: some of the comments on that issue have been deleted by the v-lang creator as they were criticizing the claims made.

However, advertising a product can do something and then releasing it stating it cannot do it yet, is one thing, but accepting money for a product that does not what is advertised, is fraud.

If the features were advertised as goals, that would not have been an issue. But these features were advertised as existing and ready to use.

Please do not give this individual money!!!

-----

If you want to support new languages that do as advertised, please support my language Odin or Andrew Kelley's language Zig.

Both are very good languages as alternatives to C but with different philosophies behind them.

Odin: https://odin-lang.org/ Zig: https://ziglang.org/


[flagged]


Stop advertising your language as being more capable than it is.

That is the only complaint. You are advertising under false pretenses and asking for money for early access to a product (through Patreon) which does match what is advertised.


First of all the language is released on June 22. It was released today for 7 hours. There's no more early access.

Second of all, you haven't listed any of these "false pretenses". Your AST and runtime points are laughable. So is the "dependency" on glfw and freetype.


By the way, you claimed V was too primitive to build anything other than Fibonacci.

What about this? :)

https://vlang.io/img/buildv.mp4

Are you going to retract your statement and apologize? Doubt it.


> He's collecting $927/month on Patreon by deceiving generous and hopeful programmers.

Oh my. This is alarming. I have never thought that the author was already getting that much money out of this incomplete piece of software.


He's up to 56% of the income I make on Patreon for Zig, and I've been busting my ass for years, working on solving a lot of the same problems, except it's been open source the whole time, and I only ever put claims on ziglang.org that describe actual status quo available software. It's really disheartening that such dishonest tactics are so effective.


Don’t get disheartened. You are writing actual software. He is a scam artist.


So true... I'm also thinking what's the point to open source under the umbrella of this V programming language something that is no more than a couple of examples.


And that's not his only patreon.

https://www.patreon.com/vlang is the one in question

but he also has https://www.patreon.com/voltapp

Nice scam.


I couldn’t see much code in his github so I assume it’s all smoke and mirrors.

How does this even get voted so high here? Just on the claims?


Because the author is simultaneously working on the Volt IM [1] and the language to make Volt? I can't really say about Volt as I haven't used it, but it is enough to establish that some concrete development is in progress. But you can't really sell an incomplete programming language in this way.

[1] https://volt-app.com/


What does working on multiple projects has to do with code availability?


Because Volt must have been written in V (please let me know if a counterevidence exists), V must have been at least mature enough to write Volt. I'm pretty sure that V does exist at this stage, but that doesn't convince me that it is viable, nor that it can get that much money.


>Because Volt must have been written in V (please let me know if a counterevidence exists)

The source of V or any substantial V project haven't been released, and the author making inaccurate claims about the compiler (and taking donations on Patreon, by the way.) Why should we accept without skepticism that (closed source app) was written with (closed source language)?


Have you ever analyzed the released Volt binary? It has symbols like this:

    000000010001dc30 g       0f SECT   01 0000 [.text] _f_1
    000000010001eba0 g       0f SECT   01 0000 [.text] _f_10
    00000001000219a0 g       0f SECT   01 0000 [.text] _f_100
    [...snip...]
    000000010004bae0 g       0f SECT   01 0000 [.text] _f_462
    000000010002a430 g       0f SECT   01 0000 [.text] _f_463
    0000000100037940 g       0f SECT   01 0000 [.text] _f_464
    000000010001f2f0 g       0f SECT   01 0000 [.text] _f_465
    0000000100020220 g       0f SECT   01 0000 [.text] _f_47
    0000000100020240 g       0f SECT   01 0000 [.text] _f_48
    00000001000202b0 g       0f SECT   01 0000 [.text] _f_49
    [...snip...]
    00000001000182a0 g       0f SECT   01 0000 [.text] _string_add
    000000010001a110 g       0f SECT   01 0000 [.text] _string_all_after
    000000010001a020 g       0f SECT   01 0000 [.text] _string_all_before
    000000010001a090 g       0f SECT   01 0000 [.text] _string_all_before_last
    0000000100019ef0 g       0f SECT   01 0000 [.text] _string_at
    0000000100018540 g       0f SECT   01 0000 [.text] _string_clone
    0000000100018aa0 g       0f SECT   01 0000 [.text] _string_contains
    0000000100018610 g       0f SECT   01 0000 [.text] _string_cstr
    0000000100019470 g       0f SECT   01 0000 [.text] _string_ends_with
    0000000100018b30 g       0f SECT   01 0000 [.text] _string_eq
While you can always mangle symbols, it is strange that i) every symbol is in public and ii) only some of them are mangled. Therefore I think the binary was probably produced by V's C transpiler, with some V standard library functions slapped on them.

(I had to rewrite the reply because I later realized that the binary was packed with UPX, I should have thoroughly inspected strings. Sorry for inconvenience.)


yeh, smoke and mirrors. Checking all the websites the author is maintaining, the focus is on Patreon support, much less on real development and commitment. I'm also intrigued why such projects (which does not have any code openly available behind) are so high rated. I assume because many github users does not take the effort to see behind.


I wonder what will happen on the day he's supposed to open-source this thing.

Delete everything and run away with the money? Kick down the can and delay source release once more? Apologies? ("but but it's pre-alpha software!")


The release was supposed to be today. Few hours ago was changed to 2 more days.



I wonder what you will say on June 22. Delete everything?


Is it faster than Y? https://github.com/SanderMertens/y


Yes, I was first interested in his stuff when he announced the perpetually "coming soon" Volt last year. Disregard the dates, deadlines, and promises for this project.


he's getting that much money because his project looks interesting, that is what most developpers want, so they are willing to take the risk

now other language designers need to learn from this project

keep your language simple, keep dependency list tiny, make clean syntax, focus on efficiency and small file size, and you win patrons

but people often then bloat their project, with uneeded features, that makes language harder to read, and harder for tooling to support it

edit:

i love Zig, i'm not using it, but i plan to once package manager is ready and vscode plugin with autocomplete and debugging is available

please make it happen, open bounties if you can't


This smells very much like a sockpuppet...


weird how other language creators are ganging up against the author here...


I think it's weirder how shady the author is about everything. Most of the claims of the language are fabrications and on top of that the closed source nature of the things he's making are already becoming a problem.

I also think it's natural for people, both language creators and users, to react badly when they see that someone is essentially succeeding by lying to people in a space where there are honest alternatives that already work.


Because language creators do know what is possible and what is hard. I think the Odin's creator has made some mistakes when presenting one's criticism [1] but even without knowing much PL knowledge AndyKelley is very clearly showing that it is shady.

[1] https://github.com/vlang/v/issues/35 (For example, there are ways to implement generics or interfaces without AST, much harder but a possible endeavor.)


Yes, Andy Kelley being really reasonable:

https://news.ycombinator.com/item?id=20231484

Calling me a scammer because "V requires glfw and freetype". I have no words.


And also clang. If your initial release only has a code generation using clang, it is your hard dependency. Windows doesn't have a native compiler and it must have a compiler beforehand---so a bare compiler wouldn't work at all! (I know that the initial release lacked Windows. But I have no reason to believe that the Windows version will be different.)

Don't tell me that it is a pre-alpha and will be updated on 22 June, that reads like a sure way to instantly kill your reputation. Always make sure that what you have presented (not what you will present) and what you have said align to each other.


C is the L0 language needed for bootstrapping anyway.

You say "also". What else?


> C is the L0 language needed for bootstrapping anyway.

So it is your hard dependency. Describe so.

> You say "also". What else?

If you think that they are spreading the misinformation because some of claimed dependencies are actually for stdlib, you should think again. A substantial subset of HN users would think that "zero dependencies" promise extends to stdlib, as it is technically possible to have out-of-box UI and graphics in the stdlib and especially Go was famous of its independent crypto and network libraries. Your statement was not clear enough.


The graphics libraries are not part of stdlib, UI only uses system libraries that are preinstalled.

Next?


Language author here; I work on a modern flavor of a classic 90s language.

There are three problems. The first is that closed languages die [0]. V is not Free Software, which is disappointing but not atypical; however, V is not even open source, which precludes a healthy community. Additionally, closed languages tend to have bad patterns like code dumps over the wall, poor community communication, untrustworthy binary behaviors [1], and delayed product/feature releases. Yes, it's certainly embarrassing to have years of history on display for everybody to see, but we all apparently have gotten over it. What's hiding in V's codebase? We don't know. As a best guess, I think that the author may be ashamed of the particular nature of their bootstrap.

The second is that V's author makes promises and claims which are then retracted, falsified, or untestable. Most notably, source for V's toolchain has been teased repeatedly as coming soon, but has never been released. Without an open toolchain, none of the claims made on V's front page [2] can be verified.

Finally, because we can't not talk about it, V isn't a very compelling language. At best, it could be seen as an iterative improvement on Go. If V were more open, then we could make more sincere and complete comparisions, but as it is, V's author alone gets to control the comparisons [3] and benchmarks [4]. Maybe the best argument to be made is that there is room for a series of languages which focus on compile speed, where languages like Go, Jai, and V compete based primarily on how quickly they can transform zero-cost abstractions into low-level code in a single pass.

...But if that's the game, then it's only a matter of time until one of them rediscovers FORTH...

[0] https://blog.golang.org/open-source

[1] https://github.com/voltapp/volt/issues/143

[2] https://vlang.io/

[3] https://vlang.io/compare

[4] https://vlang.io/compilation_speed


Why do you call it a closed language? It hasn't been released yet. It will be open-sourced in 2 days.

> Most notably, source for V's toolchain has been teased repeatedly as coming soon,

It hasn't been teased repeatedly. It's been "coming in June" since February.

Why lie?


Why gaslight?

Can the V toolchain translate C++ to V? It could in February [0] and May [1]. You had only to document it [2]; will the feature be available at the end of the week?

[0] http://web.archive.org/web/20190226163127/https://vlang.io/d...

[1] http://web.archive.org/web/20190520021931/https://vlang.io/d...

[2] https://news.ycombinator.com/item?id=19527569


The example you pointed to, actually, yes it can.

Now, waiting for your reply on my previous question about the deadlines. Why lie?


I've not lied, nor misled, just exposed and laid bare. Let's see if you make your deadlines and get your features published.


Yep.

I'll address all their claims and lies in a blog post after the open source release on June 22.


I'm curious but too lazy to look it up myself. SO I'll just ask.

How far does the 'linux' specification go. Say I want to run a V program on AIX what kind of libraries will I need?

What about the 'windows' specification. Do the redistributables support windows 2000/7/Vista/8/8.1/10

We have a lot of different systems on our clients, mac as well. It would be nice to read concrete requirements for running to really see how much effort rolling out a V application would be.


Well, AIX is fairly unrelated to Linux...


V apps run on Windows XP without any issues. Rolling out a V application is just releasing one .exe file.


It is not that simple. If you are not careful you may end up using more recent winapi functions and/or constants that do not exist in XP. For example Rust supports XP on a best-efforts basis and as a result has broken XP support from time to time (the "tier 3" support [1] explicitly allows this situation). Unless you can run an automated CI on XP (does that even exist?!) you'd better support only recent OSes.

[1] https://forge.rust-lang.org/platform-support.html#tier-3


Nothing related to linux or windows is out yet.

macos was out, but got pulled.


Title is slightly misleading. Only binaries for MacOS have been released. Windows and Linux are coming soon. And the source code is to be released on 22nd June.


And macos binary was pulled.


thought this looked interesting a couple of months ago, still looks very interesting now.

transpiring to c means you can sneak it in at work, which is nice


No null

No global variables

No undefined values

No undefined behavior

No variable shadowing

Bounds checking

Option/Result types

Generics

Immutable variables by default

Pure functions by default

Immutable structs by default

me> Wow. That's a good feature set to have !


Yes, a very good feature set "to have". I think, at this point not even half of them are implemented. The author is doing a major disservice by presenting as if everything is complete in the main website.


you can go to vlang.io/play and see for yourself instead of spreading misinformation


I must clarify, not out of the features listed by GP, but the features listed on the website. No ill will towards you, but the source of all the problems seems to be - how you present the state of language on the website as if it already has all the features noted there. And you seem to have different standards for feature completeness [1], while others expect the feature to be completely implemented, not just a proof of concept with tons of work still required. Again to clarify, I do like the idea behind this language and hope all the best for it.

[1] https://twitter.com/8vit_devel/status/1141573808320647168


[flagged]


If by "most" you mean "one" (generics). OK. :D


[flagged]


But I don't understand. You just said "most" of these don't work. Turns out "most" is 1.

And you keep posting after this?


I do not want to blame Go, since I'm programming in Go from quite a long time and I love it, but to claim a programming language which is written in Go fast is exaggerated and an outrageous lie. Go could not match the speed of C/C++ so how can be this programming language declared as fast??


This language is compiled, not interpreted. Because of this, runtime performance is not limited by Go’s performance characteristics.

This language can claim to be very close to C/C++ in terms of runtime performance characteristics because it compiles to C.


It is not written in Go. Go was only used to bootstrap the first compiler. Newer compiler versions are written in V itself.


Ok I see now, but still we do not have any evidence about the source code.


I'm gonna jump in here too and ask; why are you doing all this to yourself?

I'm reading the comments, clicking the links to GH issues, reading websites and blogs and comments and you seem to have a following. A loyal one. A vested one. Sure there are detractors, but if you step back and look; all your detractors are fueled either by your inaction, or your lack of transparency. All your supporters trust you, which is what you want. So all you have to do to take the wind out of the sails of your detractors is come clean, stop setting arbitrary forcasts mere hours into the future (pointless, sloppy, rude to your paying supporters), and just be straight. People paid hundreds of dollars for vlang. Do you think they care if there are a few hacks holding it together? They WANT to help you with this, and you claim to "want" their help and support.... SO LISTEN TO THEM!

There are hundreds of comments in this thread (many of which from shills and throwaways) that you could chop off at the knees by simply not jerking everyone around. Do yourself, and vlang, a favor and either embrace open-source (and all that entails) or don't. Just do something to stop all the drama. I haven't been able to learn ANYTHING about vlang (and I don't know if I want to) because of all this bullshit.


> many of which from shills

This breaks the site guidelines. Please review them and follow them when posting here.

https://news.ycombinator.com/newsguidelines.html


What else should I call an account that was created today with 10 posts on this one thread?

I also broke the rules intentionally by using caps instead of asterisks. For that I apologize, but regardless of HN rules there is something going on in this thread. More than simple honest discussion.


Internet users are a million times too quick to jump to the conclusion that other internet users must be dishonest, shills, or spies, simply because they hold a different view. The explanation is nearly always much more mundane. Meanwhile such accusations are toxic in their own right—they have a poisonous effect on HN. That's why the guidelines rule out making these insinuations. I've posted a lot about this if you or anyone want more explanation: https://hn.algolia.com/?sort=byDate&dateRange=all&type=comme....

To pick just one possible explanation, sometimes people feel so strongly about a topic that they are propelled into making a new account where they had previously been lurking. I don't know which account you're referring to, so I don't know if that's the case here. However, you don't need to "call" them anything. You can respond if you want to, as long as you do so thoughtfully and substantively and without personal swipes.

https://news.ycombinator.com/newsguidelines.html

Edit: if you mean https://news.ycombinator.com/user?id=kingkong2022, we banned that account for egregiously breaking the site guidelines. A better way to express your frustration would have been to flag the egregious comments (see https://news.ycombinator.com/newsfaq.html). That brings them to moderator attention. You could also have emailed us at hn@ycombinator.com, which would have brought it to our attention sooner.


*UNintentionally.


You are right. This premature release was a mistake. June 22.


Just remember; someone who says yes first and no later is a "liar."

Someone who says no first then yes later is a "good guy."


The claims in the homepage are completely refuted by the readme in the downloaded package. The compiler is not 400 kb dependency free. It requires shit ton of stuff. The codegen as well as hot code reloading is not present, so even the compiler performance claims and hcr on the homepage are lies. Even Rust like memory management that they claimed is not there. Volt is said to be written in Vlang using the UI present in this download. But the readme says that the UI package does not run on Linux, so how can Volt be written in Vlang?

Honesty I don't see why the hype behind Vlang and why so optimistic comments here.

Vlang feels worse than a pre alpha software with a good marketing team that is just trying to make money. It does not even have the features it claims it has. But just look at its patreon, it gets much more than odin lang, which IMO is much further into development than vlang is.

That said, it would not be so bad if the developer did not make false claims and just say that this is pre-alpha software, but instead he makes bold claims and fights for them aggresively (see issue by gingerbill linked elsewhere on this page), which can now be seen that all of them have been lies.

Edit: (posting my comment from below) https://support.patreon.com/hc/en-us/articles/204914235-How-...

People with patreon accounts should report this guy.


> It requires shit ton of stuff.

No it doesn't. You can build the compiler with `clang v.c`

> But the readme says that the UI package does not run on Linux, so how can Volt be written in Vlang?

The UI package is not available for everyone on Linux yet. Doesn't mean I can't use it.

> hot code reloading is not present

It will be on June 22.

Why do you spread lies and even ask to report me based on these lies? Are you the developer of Odin, who started a similar thread 3 months ago?


[flagged]


I think you are. Immediately creating a throwaway, jumping in, and spreading lies, misinformation, just like last time, when I released the playground early.


I am the Odin creator. Please don't accuse me of spreading lies when all I have done is shown that your language is just "Not as Advertised", which I originally stated in this issue: https://github.com/vlang/v/issues/35

Note: You also deleted many comments by other individuals criticizing your claims in that issue too.


"Many comments" (2). Repeating the same lies and misinformation.

Most features requiring AST? Really? Codegeneration not possible to implement json decoding?

It's just as ridiculous as claims here like V depening on glfw and freetype.


JSON decoding of the kind you want requires either run time type information or a high level metaprogramming system, of which you store the data for the types in a sort of tree, which you could call a typed abstract syntax tree (typed AST).

Stating that V has no dependencies and then requiring dependencies means the original statement is false.


[flagged]


I don't see a single valid discrepency


[flagged]


Yes I delayed the release by 2 days to clean up readme. "Lol"


This is the first time I've ever heard of why the source release was delayed. I have also managed to see the related issue [1], which was posted too late. You should have said at the first time. [2]

You have instantly earned much reputation by releasing Volt at the first time; that reputation is much easier to lose as well. People easily gets disappointed, no matter what you have achieved (or think that you can achieved); you should be very careful. Or you can stack much reputation that your mistake or short-sighted action doesn't harm yourself.

[1] https://github.com/vlang/v/issues/287

[2] Not that I like this form of release. Proprietary languages simply don't work in the modern world.


> This is the first time I've ever heard of why the source release was delayed.

My comment was sarcasm by the way.

And sorry for the delay, I was sleeping.


I'm sorry, proprietary languages? What are you referring to?


A pledge to make your language free (as in freedom defined by FSF [1], so its antonym is proprietary) is not an open source by itself. Currently your language is not free.

EDIT: s/open source/free/

[1] https://www.gnu.org/philosophy/free-sw.html


V is going to be released in 2 days and be free with a permissive license.

You can't call an unreleased language proprietary.


You have a working playground and have briefly released a binary. At the very least the second qualifies as a distribution, an important event when we are talking about F/OSS. Your language is therefore still proprietary.

Many current programmers think F/OSS as a norm and proprietary (released or not) as exceptionally shady. Even though some may think proprietary software is acceptable, something being F/OSS is a label with the non-trivial amount of value. Your act can be interpreted as claiming that value without actually being F/OSS, no matter what was your intention.


Honestly, what is the holdup on releasing the source? Other languages are developed entirely out in the open - what are you worried about? Why not just release it today in whatever state it's in, as was previously promised?

Without releasing it you're expecting people to put blind faith in you.


> It is about dependencies required by the V compiler.

V compiler doesn't require glfw or freetype. It doesn't require anything.


Memory management points up probably the most significant weakness. Give it a destructor or a drop trait or something that can be tied to scope exit. You don't need custom memory management features if you have resource management, because then memory is just another resource.

p.s. It says in the docs that its name is not vlang. That's just the web domain.


Is there some sort of prize in the world of programming languages for coming up with names where you have to append "programming language" to every search query to find what you want?

If so, all the single letter languages are getting stomped by Go, which is already used for a verb, noun and a preexisting programming language [0].

The technology to pick new and easily searchable names has existed since it was invented in 2005 by computer scientist Randall Munroe of xkcd. Language designers should use it. There are still unique 4 letter combinations available!

[0] https://en.wikipedia.org/wiki/Go


Worst part? There's already a vlang. https://vlang.org/


There is no longer any excuse for Go to exist.

There is no longer any reason for separate scripting languages.

There is no longer any legitimate reason to write C code.

Rust had better watch its back.

I may soon begin to resent C++.




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: