Profile cover photo
Profile photo
Dani Mukusha
Fanatical about mobile and wearable technology!! Not to mention good food and drink. Amateur mobile photographer. A true technaut & tea lov
Fanatical about mobile and wearable technology!! Not to mention good food and drink. Amateur mobile photographer. A true technaut & tea lov
About
Dani's posts

Post has attachment

Post has attachment
Something free to kick of the year with a beat!

Post has attachment
As the dust settles...

Post has attachment

Post has attachment
https://goo.gl/5BtrNi
Are you an AT&T customer? Are you currently unhappy with AT&T? If you answered 'yes' to both of those questions, T-Mobile might have an enticing deal for you.

Post has shared content
Skill..

Post has attachment
https://goo.gl/a0fylw
If you missed out on the product page for the Samsung Chromebook Pro leaked last month, we now have a glimpse of all the details about the device again.

Post has shared content
Those speed test have nothing to do with the CPU or Storage speed. It boils down to the how the OS handles apps. Android 7.0 new JIT compilers addresses most of the issues since its a JIT compiler with code profiling to ART. JAVA is why Android loses during the 3rd party apps portion of the battle." So while there are philosophical design differences between Java and C, there are also performance differences. The use of a virtual machine adds an extra layer to Java that isn’t needed for C."

Overall C is faster than Java, however the gap between the two has been drastically reduced with the release of 64-bit Android 6.0 Marshmallow

"A "native" iOS app is written in Objective-C (or Swift) and compiled, whereas a "standard" Android app is written in Java and compiled to bytecode.

Android apps are compiled to bytecode by the developer. Bytecode is a compact representation of the program: smaller than the source code written by the programmer, but still not directly executable by the CPU. Some optimizations, such as dead code removal, can be made at this stage.

When you load the app on a device, the Dalvik JVM compiles the bytecode to native executable code, just as it's about to run. This is just-in-time compilation. It causes a brief slow-down while the program waits to be compiled, but after that there's no performance overhead, because the code has been compiled to native executable code.

There are some performance advantages to doing it this way instead of compiling up-front on the developer's computer. The app can be compiled for the particular CPU on the phone, taking advantage of its hardware features and using its performance characteristics. For example, it can use hardware floating-point operations if the CPU supports it. In addition, a clever JIT compiler (admittedly, Dalvik is not quite this clever) can monitor the way the program runs, and perform optimizations based on the way the program is used in real use. It might recompile the code with better branch hinting once it has seen which options are turned on and off in your environment, on your phone. An up-front compiler doesn't have this information to use.
Dalvik uses the Dalvik cache and other techniques to mitigate the drawbacks of JIT compilation. The new JVM for Android L and later, ART, replaces the JIT entirely with an ahead-of-time compiler. This compiles the bytecode to native executable code when the app is installed, to get most of the advantages of JIT without the delay loading the app.

Don't forget that Android apps don't entirely consist of Java. Developers have the NDK to write all or part of their apps in C or C++, for performance-critical parts of the app, especially for games. Special-purpose interfaces like OpenGL and Renderscript let programmers take advantage of special hardware like the GPU and SIMD coprocessor for some kinds of computation.
So really, there's no simple answer to your question. Using JIT instead of up-front compilation makes some things faster, some things slower. It's just one part of the overall performance of the OS

Performance

So while there are philosophical design differences between Java and C, there are also performance differences. The use of a virtual machine adds an extra layer to Java that isn’t needed for C. Although using a virtual machine has its advantages including high portability (i.e. the same Java based Android app can run on ARM and Intel devices without modification), Java code runs slower than C code because it has to go through the extra interpretation stage. There are technologies which have reduced this overhead to the barest minimum (and we will look at those in a moment), however since Java apps aren’t compiled to the native machine code of a device’s CPU then they will always be slower.

Android 7.0

In Android 7.0, we've added a Just in Time (JIT) compiler with code profiling to ART, which lets it constantly improve the performance of Android apps as they run. The JIT compiler complements ART's current Ahead of Time (AOT) compiler and helps improve runtime performance, save storage space, and speed up app updates and system updates.

Profile-guided compilation lets ART manage the AOT/JIT compilation for each app according to its actual usage, as well as conditions on the device. For example, ART maintains a profile of each app's hot methods and can precompile and cache those methods for best performance. It leaves other parts of the app uncompiled until they are actually used."

Besides improving performance for key parts of the app, profile-guided compilation helps reduce an app's overall RAM footprint, including associated binaries. This feature is especially important on low-memory devices.

ART manages profile-guided compilation in a way that minimizes impact on the device battery. It does precompilation only when then the device is idle and charging, saving time and battery by doing that work in advance.

http://www.androidauthority.com/java-vs-c-app-performance-689081/
Photo

Post has attachment

Post has attachment
https://goo.gl/TwXUIl
Among all the outstanding Android features and shortcuts I've ever used, I realized that my favorites all use a double tap gesture to activate...
Wait while more posts are being loaded