Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

I'm planning to write a single API that is syntactically valid in most major programming languages (to the greatest extent possible, so that only minimal amounts of code will need to be re-written when moving from one language to another). I think the simplest way to do this would be to write a group of functions that consisted entirely of function calls and variable assignments, since the syntax for function calls is almost exactly the same in all major programming languages.

Of course, I'd need to write "wrapper" functions for if-statements and while-loops, since the syntax of each of these is different in each programming language.

Here's a proof-of-concept for one "polyglot" function that should work in most programming languages:

//JavaScript syntax
function proofOfConcept(){
    printSomething("This is just a proof of concept."); //the function printSomething will
    //                      need to be implemented separately in each programming language.
}

//Java syntax
public static void proofOfConcept(){
    printSomething("This is just a proof of concept."); //the function printSomething will
    //                      need to be implemented separately in each programming language.
}

//Python syntax
def proofOfConcept():
    printSomething("This is just a proof of concept."); //the function printSomething will
    //                      need to be implemented separately in each programming language.

//C syntax
void proofOfConcept(){
    printSomething("This is just a proof of concept."); //the function printSomething will
    //                      need to be implemented separately in each programming language.
}

Would this be a useful design strategy, or is there a better way to do this? I think this would be a useful strategy for developing libraries in multiple programming languages, althogh it would require a small number of "language-specific" functions to be written for each target language.

share|improve this question
3  
I'm not sure why this would be helpful. Can you describe the problem you're trying to solve? –  ipaul Mar 18 '13 at 2:47
3  
infoq.com/articles/API-Design-Joshua-Bloch; "it is almost always wrong to transliterate an API from one platform to another" –  Ismail Badawi Mar 18 '13 at 2:49
2  
Ah, okay. Normally, this is done by picking one language in which to implement (i.e. C) and then using tools like SWiG to bang out interfaces that call the C code from other languages. As someone using your library I should care that you have a method called 'proofOfConcept' but I shouldn't care how you chose to implement it. –  ipaul Mar 18 '13 at 2:50
1  
What isbadawi said. While your api may be syntactically valid, the use of it may not be idiomatic for one or more of the languages you are targeting. I personally would rather use an API that takes advantage of the language features available so I don't have to write more code. –  mortalapeman Mar 18 '13 at 2:53
2  
Yeah don't do this. As everyone is saying, this is going to be way more work than you think, and it's not really going to benefit you as much as you hope. –  Nate W. Mar 18 '13 at 3:35
show 7 more comments

2 Answers

First question - is it useful? Not particularly. Trying to make one API that fits a multitude of languages is often a mistaken approach. There are several different programming types listed in the example:

  • C - classic procedural programming
  • JavaScript - multi-paradigm tending to functional and object oriented
  • Java - Object Oriented.
  • Python - multi-paradigm tending to object oriented

The way of thinking in each of these languages is particular to that language. One can try to write procedural code in all the languages - completely ignoring polymorphism and just reverting everything to C like struts, but it would not integrate well with others. It would also forgo all the advantages of writing in a higher level language. Passing around dumb objects to static procedures defined somewhere - that is so 1980s.

The question of why really shows up. What practical use would this serve? If I am writing C code, I'm writing C code. Polyglot shops exist, but they are not the norm (it is much easier to hire 6 programmers for one language and get stuff done than it is to hire 1 programmer in each of 6 languages and get the same amount of stuff done). Rarely does one find a programmer that is writing Java and C at the same time where the perceived advantage of having one library API that fits both Java and C could be of a very small advantage.

What you are talking about is implementing a domain specific language (the printSomething(String) of the polyglot API) as a runtime environment in a multiple languages. This isn't impossible, but isn't that useful either. This is harder than one imagines - Python's scope is based on indentation, Javascript's semicolon is a statement separator as opposed to the statement terminator in Java and C (and non-existent in python).

This isn't an impossible task, but really, it isn't that useful.

share|improve this answer
    
If that's the case, then would I be better off manually porting an entire API (possibly with 200 different functions) into 8 different languages, instead of writing a single API that is syntactically valid in all of these languages (which would depend on just 10 or 20 language-specific functions in each language)? –  Anderson Green Mar 18 '13 at 14:17
    
Yes. Consider the difficulty alone of writing something to make it so that there is some structure for arrays that is common to Javascript and Java - String[] theStr = {"Hi!"} and var theStr = ["Hi!"] When you can find a way to do this with the same syntax. –  MichaelT Mar 18 '13 at 14:35
    
To solve this problem, I'd probably need to represent arrays as JSON strings, and then write conversion functions to convert the strings to string arrays in each language. Fortunately, there are already some libraries for this purpose: google.com/… –  Anderson Green Mar 18 '13 at 14:55
add comment
up vote 0 down vote accepted

The Katahdin programming language was designed to solve this problem. Its documentation includes this example, which combines Fortran and Python functions in one file:

import "fortran.kat";
import "python.kat";

fortran {
    SUBROUTINE RANDOM(SEED, RANDX)
        INTEGER SEED
        REAL RANDX
        SEED = 2045*SEED + 1
        SEED = SEED - (SEED/1048576)*1048576
        RANDX = REAL(SEED + 1)/1048577.0
        RETURN
    END
}

python {
    seed = 128
    randx = 0
    for n in range(5):
        RANDOM(seed, randx)
        print randx
}
share|improve this answer
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.