AI converts between hundreds of programming languages (codelanguageconverter.com)

I think I broke it.

    Input: TypeScript
    Output: QuakeC
    Code: Sample 3

Seems to spin forever. (Which makes sense, as QuakeC is incapable of the constructs in Sample 3).

Edit: after a few minutes spinning it's... Spewing a lot of nonsense. It seems to be dumping every variable combination it can "think" of that it has seen in QuakeC.

Ah damn I ran out of free credits after like 2 basic runs.

Definitely not enough of a taste to convince me to spend money on this. Might want to adjust that freemium model.

It's a cool idea for sure and could definitely be useful though.

Just tried the default example from C to Forth. It gave an answer but also appended two other commented Forth functions to it.

Also, this almost immediately adds a signup wall not for the real product, but to the little demo box on the home page that makes it not worth playing with

Tried pasting a big piece of code. "Whoah, that's big, try something smaller." Ok, paste small snippet of code. Click "translate". "Sign up first". Urgh, fine, this looks just about exiting enough to try, but barely so.

After signing up, I have zero credits, without a single translation performed. I mean, not that I expect free lunch, but I'm also not gonna pay money before seeing a single 10 line example.

Interesting going from untyped languages to typed languages, as an inference needs to be made.

For example, in JavaScript:

function add(a, b) {

  return a + b;

}

converting to Go, it becomes:

func add(a int, b int) int {

  return a + b

}

Where as the original JS version works with integers, floats, strings, arrays, etc.

I just want AI that will write a unit test for me.

When trying Sample Code 3 converting the TypeScript to Python the conversion was incorrect. Probably worth swapping that out for another sample if the owner is in this thread. As I was writing this I noticed that this wasn't a Show HN post.

Sample 2, typescript to c++: infinite loop. It just keeps spitting out code

I have written translators and they are really hard. I think training on code bases is the way to go but I am skeptical overall that it is even worth the effort. The problem is that the translation doesn't get you all the way there. The code produced is buggy and wrong in most cases. You probably get a better result from re-designing and re-implementing.

I wonder what the data being trained on even is. It has to include successful translations, right? There are not many of those. Not enough for a good result.

Asking me to sign up just to give it a little try made be hit the close tab button real fast.

finally: fully automated memory corruption

First underwhelming AI post on the frontpage. Thank god our jobs are safe atleast!

RUBY... def add(a, b)

return a if b.zero?

return b if a.zero?

a + b

end

Now lets see elixir :)

I say the trial should allow at least one bit of code that we provide.

Not a good sign that this website thinks Java is an acronym. And has both "Lisp" and "Common Lisp".

I had a particularly funny result: Trying sample #3 (put a record into S3) from Typescript to Python, it reliably... outputs a completely different program, which instead downloads an image from S3 and resizes it in /tmp. Weird.

I think the best case something like this could achieve is a syntax translate and nothing more.

At best I'd get Ruby code with elixir syntax.

Programming languages require thinking about memory and code differently. That's why we have them.

I'd be interested to see this in elixir :)

while (s++ = t++);

Seems completely broken now; like others, I tried to test something, found I had to sign up, signed up, and found I have "0 free credits".

I really wanted to see what it was gonna do for Python -> C++ converting some nested dictionary and list comprehensions:

    def foobar(x, y):
      return {
        _: __
        for _, __ in zip(
          [_ for _ in x if _ in y],
          [_ for _ in x if _ not in y]
        )
      }
        
    {3: 1, 4: 2} == foobar([1, 2, 3, 4], [3, 4, 5, 6])

  std::map<int, int> foobar(std::vector<int> x, std::vector<int> y) {
    std::map<int, int> map;

    for (int i = 0; i < x.size(); i++) {
      if (std::find(y.begin(), y.end(), x[i]) != y.end()) {
        map[x[i]] = x[i + 1];
      }
    }
    
    return map;
  }

    #include <algorithm>
    #include <iostream>
    #include <map>
    #include <vector>

    std::map<int, int> foobar(std::vector<int> x, std::vector<int> y) {
      std::map<int, int> map;

      for (int i = 0; i < x.size(); i++) {
        if (std::find(y.begin(), y.end(), x[i]) != y.end()) {
          map[x[i]] = x[i + 1];
        }
      }

      return map;
    }

    int main(int argc, char** argv) {
      std::vector<int> ex{ 1, 2, 3, 4 };
      std::vector<int> wy{ 3, 4, 5, 6 };
      std::map<int, int> result = foobar(ex, wy);

      std::cout << "{";
      for ( const auto &item : result) {
        std::cout << item.first << ": " << item.second << ", ";
      }
      std::cout << "}" << std::endl;
    }

    {3: 4, 4: 0, }

    {3: 1, 4: 2, }

Demanding a signup for a toy like this is rude.

Like demanding an email address to tell someone the punchline to your joke.

Hmm, it wasn't able to convert from Fortran to Matlab for the first exmample, but it seems to have produced legitimate C++ from Fortran.

So I guess... this spells doom for the quants but the scientists can sleep soundly.

Tried converting a Typescript function that returns the sum of a and b, and it generated: +

Clearly not ready for prime time.

You can accomplish something close to this with GitHub Copilot (or OpenAI Codex), just write some code in a comment and then say “rewrite the above (language) code in (language)”. Typing the first few characters of the converted version yourself helps with accuracy.

Tried CHIP-8 and so far I got

// TODO: Translate the above Rust into CHIP-8

### TODO

and now it got stuck on emitting some assembly. I don't exactly know what because CHIP-8 doesn't have an assembly representation.

It printed this 16 times

  @0000
    LD V0, [I]
    LD V1, [I + 1]
    LD V2, [I + 2]
    ADD I, 3
    LD V3, [I]
    LD V4, [I + 1]
    LD V5, [I + 2]
    ADD I, 3
    LD V6, [I]
    LD V7, [I + 1]
    LD V8, [I + 2]
    ADD I, 3
    LD V9, [I]
    LD VA, [I + 1]
    LD VB, [I + 2]
    ADD I, 3
    LD VC, [I]
    LD VD, [I + 1]
    LD VE, [I + 2]
    ADD I, 3
    LD VF, [I]
    LD I, V0
    LD V0, [I]

I applaud the effort of whoever put this together, but it is a toy, and a broken one at that. Trivial examples break it easily. When an "AI" like this can take 5,000 lines of SAS in a single file where execution starts at the top and finishes at the bottom with nary a function or external module to be found written by a government employee who hates his job and really doesn't think you should be reading his source code and can turn it in to comprehensible Python that is readable I might be interested. But this is most likely going to be a case of GIGO.

Yet another simple gpt3/codex wrapper. Monetizing is hard if not much value is offered on top of the AI.