1

Quoting from this academic paper: Syntactic and Semantic Prediction in Dynamic Languages:

IntelliSense is practically based on the knowledge of variables type. Hence the symbols describing variables have to contain their type if it's known and if it could be resolved Moreover in dynamic languages one variable can carry different type instance in different parts of the code and in different program executions. Also the variable can be initiated dynamically, and its type can be known only at runtime. Therefore the symbol should contain some list of possible types resolved within semantic analysis. But in general it cannot be resolved definitely in dynamic languages; even single program execution won't help.

Where can I find more resources on this, I am interested especially on the emphasized statements in the above block-quote, eventually some statistics on the rate of prediction on static analysis of code.

Eduard Florinescu
  • 16,747
  • 28
  • 113
  • 179
  • 2
    This is pretty theoretical, you might try the Computer Science SE site. While the answer is right that it is fundamentally unsolvable, that doesn't mean there isn't research into heuristics that are good in some subset of cases. – SAJ14SAJ Nov 25 '12 at 21:16
  • @SAJ14SAJ You are right about this, but it all stem out from the fact that I was trying to track a variable type using the AST(Esprima) of a javascript program, and saw that it always had a lot of particular cases and was wrong about the type many times. In my research I started from a practical point of view. – Eduard Florinescu Nov 25 '12 at 22:17
  • I understand, but in this area, the veil between theory and practice is thin. My guess is that academics will have the best research. Unfortunately, it will probably elucidated with examples in Scheme or Haskel or LISP. :-) I cannot offer more--this is far from my area of expertise. – SAJ14SAJ Nov 25 '12 at 22:27

1 Answers1

2

What this says is essentially the famous Turing incomputability result: in general, you can't know the answer to what a computation does (or generates as a type).

While this is true in general, it says nothing about specific circumstances. A little thought should convince you that if programmers didn't have some idea what the type of some identifier was, they probably couldn't write any code that used it. So the original coders know (unless they wrote buggy code). But they know by making assumptions about the rest of the system, and then enforcing those assumptions (often elsewhere).

A static analyzer doesn't know what assumptions the programmers made, so it can't be as precise. But in many specific circumstances a static analysis can infer the type. The question is, how much of the code does it have, and can it interpret that code using the deep semantics that make the languages behind the code?

I'm always bothered by the concept that "analyzers can't be (as) good (as humans)". If an analyzer has access to the same information the human has, it should be at least as good, and often better; it can keep track of interactions in ways people cannot. More importantly, if the static analyzer hasn't got access to key assumptions behind your code, how can you expect other programmers to work on that code? What a proiri reason exists that insists they know all the background/assumptions used in some block of code?

So I think much of the limitation of static analyzers, even applied to dynamic languages, is caused by our unwillingness or inability to write down the assumptions that we use when we write the code. (After that, there's the problem of the energy to engineer a suitably strong analyzer).

Ira Baxter
  • 93,541
  • 22
  • 172
  • 341