6 ms·

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

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.)

mpranjic 7y ago
You can read about differences here: https://vlang.io/compare https://vlang.io/compare
ksec 7y ago
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
- mhh__ 7y ago
  > No GC How does that improve upon Go? Memory safety is much harder without a GC
  - botto 7y ago
    Isn't it usually game programmers who advise against GC because you can't predict when it will run and the performance impact it will have.
    - mhh__ 7y ago
      Game programmers and also people who seem to think that Garbage Collection involves burning babies and the hundreds of academics and engineers working on it are somehow doing it out of spite. There are reasons not to use a Garbage Collector but 99% of the time they are absolutely fine if you understand what your particular GC does and does not do
  - gbear605 7y ago
    GCs are good for some things and bad for others. I wouldn’t want to write an OS with a GC but I also wouldn’t want to write a web server where I have to manually allocate and free memory. It’s all a trade off.
    - mhh__ 7y ago
      You shouldn't be manually allocating memory anywhere if you malloc and free. I feel quite strongly about the use of C in modern systems code: The "C" way of doing things can often be very unsafe or at least prone to being unsafe (No fault of the programmer, but if you don't provide RAII and things like that by default it becomes too easy to double free or leave bounds unchecked) A kernel doesn't really need a garbage collector, but keep in mind that some modern GCs can literally be tuned to have ms pause times on absolutely enormous heaps which given that reference counting can have unbounded pause times too can make them an enticing option. The real reason to avoid garbage collection is typically memory usage in my experience
      - gbear605 7y ago
        Yeah, I was using “manually allocating” as a synonym for malloc and free, but they are actually different things.
  - FpUser 7y ago
    It is not in my opinion. With modern development tools/frameworks providing memory leaks detection I have completely forgotten when was the last time that my programs leaked memory. And I write complex high performance game servers that run for months non stop. You just have to acquire certain culture/behavior when writing code.
    - crimsonalucard 7y ago
      What languages/tools/frameworks/behavior are you using to develop these game servers with no leaking memory?
      - gravypod 7y ago
        I've found valgrind and the clang static analysis tools to be a pretty nice combo.
      - FpUser 7y ago
        for c/c++ I use Visual Leak Detector and Valgrind. For Delphi/FreePascal/Lazarus there are built-in tools and also MadExcept . Behavior/patterns are different depending on task/language but generally when writing code if I want to allocate anything I first write deallocation code.
    - NoOn3 7y ago
      What tools for memory leaks detection you can suggest?
      - mhh__ 7y ago
        Valgrind (Which also has a bunch of other stuff like cachegrind, which can be a godsend if you are getting telltale cache/branch prediction issues but you can't find where etc.). Clang/GCC both have suites of sanitizers which are usually excellent and easy to grok, these are also available in many language frontends based on LLVM (and maybe GCC?) You can just throw every tool you can find at your CI if you're paranoid, too.
    - mhh__ 7y ago
- holy_city 7y ago
  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
  - ithkuil 7y ago
    I'm curious, can you make an example?
    - holy_city 7y ago
      POSIX signal handlers don't take an argument other than the signal code, so if you want to handle them gracefully in a stateful app you need a global to communicate the trapped signal to your main loop.
      - ithkuil 7y ago
        Closures could be used to implement this use case, provided that they can be exported/represented as native C function pointets, e.g. via a trampoline that captures the necessary captured context)
        holy_city 7y ago
        How would you implement the trampoline without a global? And would the captured context not count as a global? In C the only memory available to a function is its arguments and data with static duration. That static storage is synonymous with global state, if it isn't known at compile time.
        ithkuil 7y ago
        We have to distinguish what the given language exposes to its users and how the code such language generated works on the underlying hardware (along with constraints due to compatibility with other languages, most importantly C which is the de-facto system interface nowadays). A C-compatible closure basically requires an executable chunk of memory that captures the state along with the istructions to push it to the parameters area (based on the architecture's calling convention) and then jumping to the actual function. This is not global just because it's scoping the state with the function. On the other hand it becomes global the moment it gets installed to a global handler table (because there can only be one such handler). However a language that limits globals (and forces people through this kind of hoops in order to deal with cases where singletons are really needed) encourages a coding style that makes it easier to test your code in isolation.

mpranjic 7y ago

You can read about differences here: https://vlang.io/compare https://vlang.io/compare

ksec 7y ago

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

mhh__ 7y ago
> No GC How does that improve upon Go? Memory safety is much harder without a GC
- botto 7y ago
  Isn't it usually game programmers who advise against GC because you can't predict when it will run and the performance impact it will have.
  - mhh__ 7y ago
    Game programmers and also people who seem to think that Garbage Collection involves burning babies and the hundreds of academics and engineers working on it are somehow doing it out of spite. There are reasons not to use a Garbage Collector but 99% of the time they are absolutely fine if you understand what your particular GC does and does not do
- gbear605 7y ago
  GCs are good for some things and bad for others. I wouldn’t want to write an OS with a GC but I also wouldn’t want to write a web server where I have to manually allocate and free memory. It’s all a trade off.
  - mhh__ 7y ago
    You shouldn't be manually allocating memory anywhere if you malloc and free. I feel quite strongly about the use of C in modern systems code: The "C" way of doing things can often be very unsafe or at least prone to being unsafe (No fault of the programmer, but if you don't provide RAII and things like that by default it becomes too easy to double free or leave bounds unchecked) A kernel doesn't really need a garbage collector, but keep in mind that some modern GCs can literally be tuned to have ms pause times on absolutely enormous heaps which given that reference counting can have unbounded pause times too can make them an enticing option. The real reason to avoid garbage collection is typically memory usage in my experience
    - gbear605 7y ago
      Yeah, I was using “manually allocating” as a synonym for malloc and free, but they are actually different things.
- FpUser 7y ago
  It is not in my opinion. With modern development tools/frameworks providing memory leaks detection I have completely forgotten when was the last time that my programs leaked memory. And I write complex high performance game servers that run for months non stop. You just have to acquire certain culture/behavior when writing code.
  - crimsonalucard 7y ago
    What languages/tools/frameworks/behavior are you using to develop these game servers with no leaking memory?
    - gravypod 7y ago
      I've found valgrind and the clang static analysis tools to be a pretty nice combo.
    - FpUser 7y ago
      for c/c++ I use Visual Leak Detector and Valgrind. For Delphi/FreePascal/Lazarus there are built-in tools and also MadExcept . Behavior/patterns are different depending on task/language but generally when writing code if I want to allocate anything I first write deallocation code.
  - NoOn3 7y ago
    What tools for memory leaks detection you can suggest?
    - mhh__ 7y ago
      Valgrind (Which also has a bunch of other stuff like cachegrind, which can be a godsend if you are getting telltale cache/branch prediction issues but you can't find where etc.). Clang/GCC both have suites of sanitizers which are usually excellent and easy to grok, these are also available in many language frontends based on LLVM (and maybe GCC?) You can just throw every tool you can find at your CI if you're paranoid, too.
  - mhh__ 7y ago
holy_city 7y ago
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
- ithkuil 7y ago
  I'm curious, can you make an example?
  - holy_city 7y ago
    POSIX signal handlers don't take an argument other than the signal code, so if you want to handle them gracefully in a stateful app you need a global to communicate the trapped signal to your main loop.
    - ithkuil 7y ago
      Closures could be used to implement this use case, provided that they can be exported/represented as native C function pointets, e.g. via a trampoline that captures the necessary captured context)
      - holy_city 7y ago
        How would you implement the trampoline without a global? And would the captured context not count as a global? In C the only memory available to a function is its arguments and data with static duration. That static storage is synonymous with global state, if it isn't known at compile time.
        ithkuil 7y ago
        We have to distinguish what the given language exposes to its users and how the code such language generated works on the underlying hardware (along with constraints due to compatibility with other languages, most importantly C which is the de-facto system interface nowadays). A C-compatible closure basically requires an executable chunk of memory that captures the state along with the istructions to push it to the parameters area (based on the architecture's calling convention) and then jumping to the actual function. This is not global just because it's scoping the state with the function. On the other hand it becomes global the moment it gets installed to a global handler table (because there can only be one such handler). However a language that limits globals (and forces people through this kind of hoops in order to deal with cases where singletons are really needed) encourages a coding style that makes it easier to test your code in isolation.