
Show HN: Coffee++, idea for a language that compiles into C++ - jhasse
https://bixense.com/coffeepp/
======
Micoloth
I'm definitely upvoting this, as i think this is very much the right direction
(I'm actually working on something similar).

After reading into it, I think for me personally it really isn't enough
though.. These are some of the reasons why I'll never use it :

1\. using := instead of = is straigh up worse. No way i'd use 2 characters
instead of 1 for an operator that common.

2.i don't think the eventuality of bugs really justifies the repetition of
public and private at EVERY SINGLE variable, that's a lot of repetitions

3\. If I have to learn a new syntax, it really has to make my life easier:
this Definitely includes automatic generation of all needed include statements
(or import, whatever). I know there is some work to do to make it happen, but
we definitely are able to do it in 2017. No way imports are something we
should be doing by hand anymore

4\. (also a lot of other minor things that don't add meaning, like (int argc,
char __argv) that really shouldn 't be there)

Of course I hope it's clear that this is my very personal point of view :)

~~~
jhasse
> 1\. using := instead of = is straigh up worse. No way i'd use 2 characters
> instead of 1 for an operator that common.

Maybe you have mistaken := as the assign operator? It rather is for local
variable declaration:

foo := xy

becomes

auto foo = xy;

so it's 2 characters instead of 7 :)

> 2.i don't think the eventuality of bugs really justifies the repetition of
> public and private at EVERY SINGLE variable, that's a lot of repetitions

Good point. My thinking was that Java/C# seem to be fine with that decision.
Also the : after public/protected/private clashes with Coffee++'s Python-like
scopes.

> 4\. (also a lot of other minor things that don't add meaning, like (int
> argc, char argv) that really shouldn't be there)

The reason for keeping stuff like (int argc, char argv) is that I want this to
be used in C++ projects in the sense that you could have some Coffee++ files
and some C++ files together with the only difference, that your build system
translates the Coffee++ files to C++ before compiling. But I'm open to
replacing other annoyances of C++. Maybe

    
    
        int main(std::vector<std::string> foo):
    

could be translated into

    
    
        int main(int argc, char** argv) {
            std::vector<std::string> foo;
            for (int i = 0; i < argc; ++i) {
                foo.emplace_back(argv[i]);
            }
    

;)

------
drvortex
What is the point ? If it is just academic curiosity that is fine. But if it
compiles one to one to C++, then it is just a different and more Python-like
syntax for C++ ?

~~~
brudgers
Every programming language can be described as "just a different syntax" for
some other language, e.g. "C is just a different more Algol like syntax for
assembly language." The differences in syntax is what can make a language
useful (or not useful, e.g. Brainfuck).

~~~
mhh__
That isn't really true.

There are clear differences in semantics between most programming languages. C
is not just a different syntax over assembly: It has a type system, and
obviously restricts what you can do (e.g. C abstracts over the registers)

A higher level language can be translated to a lower level one, (hence why
Haskell can exist), but saying it's a purely syntactic transformation is
extremely reductive.

~~~
brudgers
A Haskell program compiles to something that uses places and mutates what is
stored in those places because a Haskell program ulitimately runs on a machine
designed with the Von Neumann architecture.

Reduction is what compilers do. In the old days C was often compiled to
assembly (at least the parts that were not in-line assembly) and the assembly
was assembled and all of it got linked into an executable. Crenshaw's classic
_Let 's Build a Compiler_ is a great way to see how it was done even if it is
written using Pascal.
[http://www.stack.nl/~marcov/compiler.pdf](http://www.stack.nl/~marcov/compiler.pdf)

~~~
mhh__
Umm, I know how compilers work.

C is compiled to still compiles to assembly, but usually (GCC) your compiler
driver handles assembling, linking etc.

Haskell is translated to core (basically a simplification of a small subset of
Haskell), then the STG(The abstract machine, spinless-tagless-Gmachine) then
Cmm (Basically unsafe C) then LLVM.

~~~
brudgers
The turtle at the bottom of Haskell is machine code...mutable non functional
machine code that is isomorphic with the Haskell source.

~~~
mhh__
The machine code can still be basically functional. GHC doesn't use any
mutable data unless you tell it to, it generates and then immediately collects
garbage rather than reuse mutable memory.

You can have mutable data in Haskell, obviously.

------
earenndil
I don't think this is a good idea. I don't like c++, many people don't, so if
we're making something better, why make it depend on c++? Why not use a
completely _new_ language, like D or nim?

~~~
jhasse
Because of existing C++ code. Most languages only have a C FFI - not C++. With
Coffee++ you can just mix C++ and Coffee++ source files.

