Question: In SDK for iOS, there is a way to send a status without open UIWebView?
Maybe a url with post body,
I really need a way to send without uiwebview form.

Thanks

Answer: 
Theoretically, the answer is **"it's implementation dependent"**. Each C compiler decides the best approach to take -- as long as it exhibits the correct behavior, it doesn't really matter how you got there.

Practically speaking, **you probably won't see a reference to variable names in a compiled program**. That's because the processor doesn't need to know or care about variable names you've assigned in order to execute your program. It operates on a much lower level: it simply needs to understand which instructions to execute and in which order. Therefore, including this information is an superfluous extravagance that would simply inflate the size of your program.

There are three basic cases, which I'll enumerate below. I'll also describe the behavior of what a typical compiler would probably do, although remember that it's implementation-dependent and in general compilers are allowed to do whatever they want as long as they exhibit the correct standard behavior.

* For local variables, as part of the compilation process, the compiler replaces each variable name (e.g. "int foo;") with a reference to the appropriate memory allocated for that variable ("memory address 0x482c"). Assignments or references to this value can typically just refer to the appropriate address.
* For non-local variables, the compiler performs additional resolution to determine how to discover, but it's usually still not storing the name of the variable or function directly.
* For things that aren't variables at all (structs, methods, etc.), the compiler performs different resolution steps and optimizations based on decisions it's made and parameters that have been set. But here, too, it doesn't store the name of the variable or function; it's just replacing it with the appropriate references.

There are cases where it's useful to include variable names in the compiler's output, like when you're debugging. In those cases, a *debugging symbol table* is created. This is a way to map *addresses* to *names* that are meaningful for humans, so that when something crashes, you can see "Stacktrace: function foo() ..." instead of "Stacktrace: Memory address 0x4572 ...".

In languages with metaprogramming capabilities, like C#, Ruby, or Java, the *names* often become part of the metadata that's stored along with the object, rather than just replacing each reference with a lookup on a memory address. That metadata comes in handy when you want to do certain neat tricks that are nigh-impossible in C at runtime, like asking "which objects in this collection have a field named `foo`?".
*When compiling the code, does the compiler basically say: "Ok myInt refers to address 0xffffff" and essentially substitute in the memory address in the machine code?*

If `myInt` is on the stack, an **offset** from the stack pointer is set aside. The compiler will remember that `myInt` is there as it compiles that function.

If `myInt` has global or file scope, it remains `myInt` until the linker can decide on an **absolute** location. 

*I'm still confused as to how the memory address itself is represented...*

Bytes in memory are numbered, ascending. So an absolute address or a stack-offset both look like an `int` at the bit-level.