And Go probably wouldn't have half the range it enjoys today without the massive reach and coffers of Google. That's not a snark, or a critique even, just a reflection of the difficulty of breaking through in this space and indeed a comment to support your assertion that in order to succeed in this space today you probably have to build on or successfully interoperate with an already established platform.
If Go didn't have the backing of Google, I doubt it'd have half the audience it enjoys today; Rob Pike notwithstanding. Case in point: Plan 9.
IMO people interested in success should be suspect. It’s weird to me that people would go through life seeking attention for invention that will not last much beyond their death.
If anyone here believes their efforts at even a Google size company are forever: 80% of the companies listed as Fortune 500 firms do not exist anymore.
Other than a few key discoveries, for a variety of reasons, none of the work at those firms is considered of value.
Err, the attention and success can help them get money, funding for their projects, and other niceties much before their death, so there's that.
I don't see how he wasn't motivated by success. He wasn't solving recreational math puzzles.
True, his definition of success didn't include money or prestigious prizes. Still, proving a great and long-standing theorem is a way greater accomplishment than becoming a millionaire.
That said, I'm not discounting what you're saying about Go's popularity either.
I do think your general point does have merit and the computer industry is littered with examples of great languages that have either failed to gain traction or just fallen out of favour for whatever reason.
Also, Rust started in the last 10 years and wasn't built on anything. Unless you count LLVM?
Granted, there are still killjoys who want to nag about how $language isn't on the TIOBE index, but they're usually easier to ignore.
From the page comparing to other languages, they claim "Zero cost C interop".
I don't have to convert C to V and then compile the entire V program, do I?
The documentation that exists is minimalist enough that I would be very careful about assuming it represents a complete representation of the language's features.
It's just `C.puts('hello')`
fn main() { C.puts('hello') }
amedvednikov is the author.
It is hard to interpret it. The V compiler parses C?
Another lesser-known example is ReasonML [0], which is supposed to integrate really well with JavaScript and OCaml. Based on my experience, it's still young with plenty of rough edges but it's very promising.
Most libraries aren’t really that useful in the long term (although the most-used are). Typically they will not do quite what you want or they will do more than you need and therefore what you want will be mixed up with a lot of other things you need to specify. In cases where a perfect library already exists for your thing there is a reasonable chance that your thing already exists, and otherwise just use whatever language the library is in.
Now there are some libraries but I claim that basically everything else you can get away without and just do it yourself only adding things as you need them. E.g:
libc type library is quite fundamental. Likely a lot of the basic stuff already exists. So long as you have an ok ffi it should be easy to add any missing calls.
HTTP client. This is likely to exist but also not super hard to implement. One can also skip this and ffi/shell out to curl.
Json parser. Again likely to exist and quite easy to implement.
Data structures. Likely to somewhat exist although anything missing that you want may be a bit annoying to add. Typically I think most projects don’t hinge on exactly the right exotic data structure, and if they do then they should be implementing that themselves.
E.g. yaml parser. Less likely to exist and annoying to implement but you can just use some existing program to convert to json first and then easy.
E.g. bindings for your favourite C drawing library. Probably don’t exist but hopefully there is an ffi so just do it yourself.
Libraries aren’t really very special and rolling one’s own isn’t hard. And even if you refuse that, you can just write part of your project as a simple unix process and call that from your python script with all the libraries you want.
Personally I see the lack of libraries as an opportunity to not search around for libraries or try to work out how they can go wrong or be forced to do things a certain way. Especially if the language is novel, it probably isn’t really clear how such a library should be structured. E.g. the reason that rust doesn’t have a canonical gui library isn’t that there are no libraries or no one is trying or no libraries exist but rather that the community in general are still trying out different approaches trying to find something that fits the language well. On the other hand the OP mentions the existence of a widget library for V already.
A more powerful language like C++, Rust, or Haskell can capture much more semantics in a library. This builds on itself, so that spending time optimizing a library is worthwhile if the library starts out more useful. Putting more work into a library benefits every user if the library can absorb the extra work.
Obligate-GC cuts library authors off at the knees, so otherwise powerful GC languages tend not to collect libraries.
Go, your exception, is by far the most successful of the languages listed.
Go is 10 years old, scala is 16 - 60% older, and it was built on top of the JVM, which is much older than that.
I feel like that's worth mentioning, because it seems like Go has more momentum - maybe there's data that shows otherwise though, like trends in Redmonk over time. I had a quick look and didn't see an easy way to get that. I'd be happy to be proven wrong, it's just the impression I get.
And there's nothing wrong with that.
It might have worked for Clojure and Scala, but didn't get tons of other JVM targeting languages very far.
And inversely, C, C++, Java, Python, Perl, Go, Rust etc succeeded by themselves.
It’s extremely popular and I could foresee it eclipsing new Java projects going forward.
Java and Go didn't take that route, because they had corporations behind them that could put a lot of people on writing a solid, broad library fairly quickly. When C came out, the standards were a lot lower - a few people wrote the library that they wanted. Same with Perl. (CPAN is an amazing organic achievement, but it took time to develop.) When C++ started, it just used C's library. I don't know about Python.
Rust is the exception to my reading of this, but even Rust had a large organization, even if it wasn't a corporation. So I think the rules are be early, so standards are lower; have a big organization write a big library at the beginning; or use an existing library to get off the ground.
Doesn't that always lead to compromises in the language design (to easily link to the old language) and sub-par non-idiomatic libraries?
But there are different degrees. C++ had "extern C", which is not much. Java, get the same ability, had JNI, which is gouge-your-eyeballs-out ugly.
A language can probably survive having something like "extern C" to be able to get to the libraries. But if JNI were the way to get to the standard library, it probably would have killed Java.
I think this can be an option in the future. The language is simple enough.
But a lot of people have been telling me it isn’t a “real” language and that I need to target either C or LLVM. Can’t please everyone, I suppose.
Frustratingly I saw a fun-looking language posted here before, which was a virtual-machine based system. It was small, clear, and had a good range of libraries and I'm damned if I can find it again!
Were either of these two the ones you were thinking of?
https://pharo.org/ - A language with an IDE
http://pixielang.org/ - A lisp.
Sadly not a match. All I remember was that the language was written in C, compiled to bytecode and was executed in a virtual machine (like Lua, and similar languages). It was "small" and "fast" and probably had a C-like syntax.
I should perform a decent search, because the more I think about it the more I'm annoyed now!
I should just post an "Ask HN: Tell me of your niche languages" and hope I get lucky!
Question though; I'm assuming that if you're touching C, there's no extra protection added by V, right? The C will be just as unsafe as it was before, or do you add some kind of exception handling thing around it?
Strings are simple: 'hello'.cstr()
So are arrays: [1,2,3].carray()
But if you work with pointers, you have to be careful. Maybe I'll implement an unsafe block.
Looks like they just have a way to return errors if you use question mark at the end of function declaration. See "Option types" here https://vlang.io/docs
If you are building a language, starting from scratch is the epitome of Not Invented Here syndrome. Build it on top of an existing ecosystem. Look at Elixir and how it builds on Erlang and interoperates with it just perfectly. Or look Groovy, Scala and Clojure to see what kind of range you can get from a single platform. With the exception of Go, every language that has become popular in the past 10 years, built on something else.