RosettaGit: Same projects in many programming languages

I’m surprised Lisaac is in the list, I thought the author stopped developing the compiler.

The first link I clicked was the one leading to https://rosettagit.org/tasks/bitmap/ . The first link I clicked there was the one labeled "write ppm file" leading to https://rosettagit.org/tasks/write_ppm_file, which 404s. Was I exceptionally unlucky?

Something that uses Repl.it or tio.run or klipse would be even better.

There's a GitHub extension to transclude content from a GH repo into a MediaWiki page, allowing the code to be managed separately from the wiki presentation: https://github.com/JeroenDeDauw/GitHub#github-extension-for-...

There's an older, more generic git transclusion extension for MediaWiki that needs a maintainer and updates: https://www.mediawiki.org/wiki/Extension:Git2Pages

And approaching the problem from the other end, there's the git porcelain git-remote-mediawiki that translates git commands into MediaWiki API requests: https://github.com/Git-Mediawiki/Git-Mediawiki

Git-Mediawiki is also known as mw-to-git in git's `contrib`: https://git.kernel.org/pub/scm/git/git.git/tree/contrib/mw-t...

In Rosetta Code you can split the code and insert some text and formulas between them. Sometimes it makes the explanation easier. Also, the free form in useful to add different ways to solve the task and compare them.

The problem is that you must trust your cut&paste abilities to not break the code :).

That would be possible for purely funcional languages, but the mainstream ones allow side effects that you can't quite predict. Remember training a model is just teaching a machine to memorise statistical occurrences. Anything the model doesn't anticipate can be catastrophical.

I could see something like control engineers do, use machine learn to help tune a controller. In this case, use a model to generate an aproximation code translation with accompanying degree of precision.

Lots of languages have different assumptions about which edge cases you must handle or are handled automatically for you, or what restrictions you have. How do you account for a language which allows memory management or not? One that has higher- vs. lower-level threading APIs? These can be handled, but consider the complexity necessary to do so for only a single language. Then, imagine the thousands of other things you can't call to mind until you hit them as a crazy edge case trying to do this. While it may be theoretically possible, this means such a model is probably not the best tool to do this.

Wow very impressive. Did you write all of these?

I clicked "Send Email" and scrolled down the page, curious what might help out my recent PHP rage.

And what to my wondering eyes should appear? A concise PHP example using several undocumented features!

Thanks!

It literally says this in the link:

  The data was originally forked from rosettacode.org on 2019-10-22. In comparison to Rosetta Code, in RosettaGit all code is stored and hosted in a repository on GitHub instead of a MediaWiki. This has following advantages:

   * Code can be edited with proper text editors
   * Continous integration and delivery can be used to ensure a high code quality
   * All infrastrucuture for git (e.g. GitHub) simplifies further development
   * Faster load times as pages are only rebuilt after a change

They need to benchmark Lua. Lua is ridiculously concise when it comes to implementing algorithms.

https://rosettacode.org/wiki/Category:Lua

Wolfram Language has an absolutely huge "standard library" though which probably accounts for some of this.

I would believe so. Things like dynamic programming (memoization) takes only a few characters, not to mention a wealth of facilities already built in. It's what I use for prototyping math-y software.

If you discount its standard library however, I think it might not necessarily beat APL.

Why is it important to ensure that the implementations are comparable? Why would someone contribute one that isn't? And if a language has to do something unusual because of specific quirks, I'd argue that's interesting by itself, and demonstrates how languages are similar and different (the stated goal of Rosetta Code).

Rosetta Code is specifically not a collection of library code. You're not supposed to take code from there, so it doesn't matter whether they all implement exactly the same thing.

The advantage over GitHub is that it's much easier to find what you're looking for, and the code you will find will (supposedly) be written explicitly for expository purposes.