Quais são algumas maneiras de manter as bases de código escritas em duas linguagens que implementam a mesma lógica?

Eu tenho um algoritmo lógico intensivo que preciso codificar em dois idiomas (na verdade, terminei satisfatoriamente em um idioma e estou prestes a começar a codificar no outro idioma). Por lógica intensiva, quero dizer que o algoritmo não é trivial, precisa de compreensão cuidadosa e, o que é mais importante, pode estar tendo bugs (devido à complexidade e descuido, você sabe) que precisariam ser corrigidos no futuro.

Além disso, quero ter certeza de que, quando esse código mudar de mãos, eventualmente, ele não deve sobrecarregar os novos programadores.

Diante desse cenário, de que maneiras algumas ajudariam a manter as bases de código e mantê-las sincronizadas? Por formas, quero dizer ferramentas de software, práticas recomendadas etc.

Para sua informação, as duas linguagens são C ++ e Java. C ++ para Windows / Linux e Java para "tudo o resto", incluindo Android.

Resposta curta: não faça isso a menos que seja absolutamente forçado.

Se você precisar usar C ++, considere usar o NDK para criar seu algoritmo para Android em C ++ e, em seguida, adicione um wrapper Java fino para a interface do usuário. Observe que o uso do NDK significa que seu código é muito menos portátil para diferentes tipos de hardware. Definitivamente, não é preferível usar Java em qualquer lugar, mas é melhor do que ter duas bases de código.

Se você absolutamente não pode fazer isso e precisa ter duas bases de código, aqui estão três sugestões:

1) Procure uma ferramenta como o Unity voltada para o software portátil.

2) Tente inserir os bits complexos do código em dados ou em alguma linguagem de script. Se você pode escrever um código bastante genérico para lidar com a linguagem de script, é mais fácil testar e acertar duas vezes. (Especialmente se for um idioma padrão criado por outra pessoa.) Então você pode ter uma base de código para os bits complexos. (Você pode experimentar o Lua, que é voltado para a incorporabilidade.)

3) Como a outra resposta indica, crie um conjunto de testes para validar os dois conjuntos de códigos. Note que isso é realmente difícil de acertar. Tendo feito exatamente isso, posso dizer que isso se deve a muitos debates sobre qual versão é "correta", especialmente em casos de erro.

(2) e (3) podem ser usados ​​juntos.

Crie um único conjunto de testes externo que garanta que ambas as bases de código se comportem da mesma maneira. Eu coloco uma ênfase extra na palavra "único" porque, caso contrário, você terá que manter dois conjuntos de testes que podem diferir em suas afirmações. Não tenho sugestões de como fazer isso, mas parece ser uma maneira de manter sua sanidade (e de futuros desenvolvedores) ao trabalhar nesse tipo de base de código.

você pode usar uma linguagem que pode ser compilada em código de máquina e código de byte java, transformando primeiro em java e C ++ ou diretamente. A última vez que verifiquei que o LLVM possui back-ends para ambos

edit: um pouco de navegação wiki me levou ao GCJ, que pode compilar java para código de máquina

Na minha opinião, a regra mais importante para um programador é "Não se repita". O que você sugere é uma clara violação desta regra.

Eu seriamente sugiro que você encontre uma maneira de implementar o algoritmo apenas uma vez. Atualmente, posso pensar em duas abordagens diferentes.

• Use um idioma específico do domínio. Talvez o algoritmo possa ser melhor expresso em uma linguagem diferente, por exemplo, uma linguagem de script, para a qual possa existir um analisador em todas as plataformas em que você espera executar o aplicativo ou gerar código C ++ / Java com base no código DSL.

• Escreva tudo em C ++. O C ++ pode ser compilado em praticamente qualquer plataforma. Se em algumas plataformas você precisar que o aplicativo principal seja escrito em Java, acho que é possível chamar uma biblioteca nativa (não tenho muito conhecimento em Java, mas presumo que isso possa ser feito).

Manter o mesmo algoritmo em duas plataformas diferentes só pode causar problemas e problemas.

Além do excelente conselho para usar um conjunto de testes externo comum, convém analisar a programação alfabética . As ferramentas de programação alfabetizadas permitem produzir vários arquivos a partir de um único arquivo de origem.

O uso tradicional do LP é permitir intercalar a documentação com o código de uma maneira que permita manter a documentação muito próxima do código-fonte. Um único arquivo noweb (por exemplo) pode ser usado para gerar um arquivo de documentação que pode ser compilado em um documento maior usando (digamos) LaTex, e produzir um arquivo .cppe .hque pode ser compilado em seu aplicativo.

No seu caso, pode permitir que você mantenha as bases de código e a documentação juntas, produzindo um .javaarquivo também.

Manter as versões de código de documentação e diferentes juntos em um único arquivo, divididos em seções logicamente equivalentes, deve torná-lo muito mais fácil para mantê-los todos em sincronia uns com os outros.

Este é um bom exemplo de onde os testes podem ser úteis.

Gostaria de sugerir ter um único conjunto de testes que tanto a sua base de código executado contra. Então você sabe que suas bases de código estão em conformidade com a mesma especificação!

(e, tenha uma boa cobertura de teste!)

Considere o código que gera C ++ e Java a partir de alguma outra linguagem

aviso Legal

Como mencionado nas postagens anteriores, se você realmente não tem outra opção, então.

Responda

Várias sugestões práticas, em vez de uma única resposta:

(1) Use estruturas comuns, mesmo, se as mesmas coisas puderem ser diferentes.

Exemplo: eu precisava ter o mesmo código em "Object Pascal" e "C ++", onde a sentença "if" existe em ambos, o parêntese em "C ++" é necessário, mas não no "objeto Pascal".

// Object Pascal
...
if MyBollExpression
begin
  ...
end;
...

// C++
...
if (MyBollExpression)
{
  ...
}
...

Alterado para:

// Object Pascal
...
if (MyBollExpression)
begin
  ...
end;
...

// C++
...
if (MyBollExpression)
{
  ...
}
...

Parênteses adicionados aos dois idiomas. Outro caso serão os namespaces opcionais versus os namespaces necessários ("pacotes").

(3) Mantenha nomes de identificadores, distinção entre maiúsculas e minúsculas, especialmente tipos, similares, use aliases, subclassificação e empacotamento:

// Java
// 
import java.io.*;

...
System.out("Hello World\n");
...

// C++
// 
include <iostream>

...
cout << "Hello World\n";
...

Para dentro:

// Java
// 
import java.io.*;

static class ConsoleOut
{
   void Out(string Msg)
   {
     System.out("Hello World\n");
   }
}

...
ConsoleOut MyConsole = new ConsoleOut();
...
MyConsole.out("Hello World\n");
...

// C++
// 
include <iostream>

public class ConsoleOut
{
   void Out(string Msg)
   {
     cout << "Hello World\n";
   }
}

...
ConsoleOut MyConsole = new ConsoleOut();
...
MyConsole.out("Hello World\n");

...

Sumário

Normalmente, tenho que trabalhar com várias linguagens de programação e existem algumas bibliotecas "principais" personalizadas, que mantenho em várias linguagens de programação.

Boa sorte.