Hacker News Reader

#5 makes a lot of sense and is often overlooked. The argument often is that it is not the tools that determine the quality, of the app, but let's see: Adobe CS5 Flash2iPhone is developed without iPhone OS 4 in sight. The main target users for it are those who are not familiar with iPhone OS and frameworks and would enjoy just pushing a button and letting the tool to do the rest. The timing is such, that a flood of apps developed this way would arrive just in time iPhone OS 4 comes out. End user does not know and does not care which tools the App was developed in. No surprise this does not look pretty in Apple's eyes. I and cannot imagine Flash2iPhone style of app producing anything about mediocre. If it targets Android too — even more so. This way all you can get is unisex, unisize sportswear. Apple wants tailor suits and designer dresses.

What if my app doesn't need all the latest features? I don't see how this argument makes sense. After all, competing SDKs don't force their users to stick to them. If somebody has already written a couple of Flash apps for iPhone, but now wants to program a 3d shooter, nobody is stopping him from switching to Objective-C.

The needs of the many outweigh the needs of the few, or the one.

I don't understand the logical step here, I am afraid?

If Apple wants to limit the total amount of applications and at the same time improve the quality, they could get rid of the literally thousands of trivial books that are each an individual application. This could be for example done by forcing them to use in-app payment for loading new books or finding another organization principle.

There are relatively few conversion applications in comparison. Conversion applications are really not a problem.

How about the twenty or more music sequencer applications? Currently I would not easily find out which one is really good. Should Apple limit people submitting these applications? I'd rather have the market decide and have users rate these applications and an effective way to search for applications that are above some rating level.

Apple should think harder about presenting these applications to the user in such a way that finding and evaluating gets easier. It might also want to think about the rating mechanism and how it works.

Apple should spend less time in legal battles or building fences.

I disagree with (1) and (2) - why would Apple want to limit Apps? It seems to me that App #'s are one of the biggest things the iPhone has on its competitors and they don't want anyone to catch up. Android nearly doubled it's Apps accepted from February to March and I'm sure Apple are aware of it. They can already control App acceptance through their review process yet they've allowed 60+ fart apps.

Also, I think there needs to be:

6.) Prevent the possibility of Adobe gaining ground with an iPhone IDE. While I think it's unlikely, Apple would be hurting if masses decided Flash was a more productive way to create the many basic Apple Apps (such as fart apps, conversion apps).

7.) Hurt the Adobe CS5 launch. Days before release, really?

Have you seen the app store lately? Check out this link:

http://appshopper.com/music/a003-guitartube

Scroll down to see the other apps created by this developer. They're all cookie-cutter apps, each one for a slightly different genre of user. He has a Picasso video lounge -- for all those users who want to join the Picasso social networking video channel. I think the number of apps is pretty meaningless when you have dozens of crappy apps like this.

Speaking of compatibility layers, there is one very direct consequence of being inefficient on a mobile platform: battery life. I've become somewhat sensitive to what I'm doing on my computer since I started using a laptop at home instead of a desktop computer. I usually avoid watching long videos or generally using any Flash app not only because it eats up power terribly when it works, but I may find a defunct Flash process hanging there eating up some 20% of CPU even after I close the page with Flash. The problem seems to have gone away lately, but bugs are bugs, you can't expect exceptional quality from Adobe. Neither from any other developer, especially if we are talking about cross-platform runtimes.

Apple's decision starts making some sense to me now (I don't develop for iPhone, so the ongoing drama is rather distant for me). The choice of languages - C/C++/Objective-C - clearly indicates that Apple wants efficiency, not just quality. Just add one layer between the language and the CPU (e.g. a virtual machine) and your phone's battery will die 5 times faster.

I'm sorry for the dynamic language folks, but we are back to the era of bits and bytes, at least when it comes to smaller mobile devices. I think smarter manufacturers of mobile devices will do something about it pretty soon, once they see the boost of quality in the iPhone market. Provided that actually happens, of course.

That's also 'Unfug'. Flash is just bad - especially if it does not use any hardware acceleration offered by the machine for video decoding.

Battery life is not much affected by a dynamic language. Because no one with a clear mind will implement things like decoding of video in a dynamic language. But what people want is to implement GAME LOGIC in another language and not in C.

The real battery life that matters is based on costly processes (like flash) and using costly services.

Navigation is such a thing. There are many many applications for Navigation. ALL of them are a huge source of emptying your battery.

I have used a single navigation application presenting a map and recording my track - battery life goes down to two hours. The reason is the screen, the internet connection for the map and the GPS receiver - all demanding power.

But people want to use those things. So in a car the iPhone gets electricity from the car. On a bike there are electricity adapters also.

There is NO reason to assume that a software written in a high-level language and translated to C will empty battery five times faster.

YOU CAN WRITE BATTERY EMPTYING SOFTWARE IN ANY LANGUAGE - AND SOME OF THESE APPLICATIONS ARE VERY USEFUL - LIKE NAVIGATION APPLICATIONS.

Take for example a program for the iPad that plots complicated mathematical formulas.

Apple forbids translating the formulas to machine code on the iPad - because that would implement another programming language and runtime on the iPad. So Apple's restriction SLOWS things down. At the same time besides computing the formula the plotting application does mostly calling UI function (drawing, 3d stuff, etc.) and waits for user interaction (zooming, rotating, ...). You can write that part in any language - it is mostly calling platform functionality. So in this domain it either don't matter (because the UI code is mostly calling to the platform) or is getting worse because of Apple's policies (because you can't compile complicated formulas on the device, because that would violate Apple's developer restrictions).

There is NO reason to assume that a software written in a high-level language and translated to C will empty battery five times faster.

Do you know how (a + b) works in different languages? Have you ever looked into Python, Ruby, Java, C/C++ (and (+ a b) in Lisp if you wish)? The difference is huge.

In dynamic duck-typed languages (a + b) means checking the types of the operands before you can decide what + means and before you actually do something, for example add integers, or maybe float's, or maybe concatenate strings, or maybe throw an exception if anything's wrong with the operands. Let alone variables take up more space - and that's another source of power consumption - because they can be of any type.

From my observation, dynamic languages are 3 to 10 times less efficient. And I wouldn't bet on developers' "clear mind" like you said.

Edit: and I'll let you go with "bullshit" (which you edited later) and a lot of irrelevant, emotional demagogy.

Most code in these languages is not computational intensive. That's not what they are for. Much of that code is calling platform functionality and library functions. Try to check some Perl on text processing vs. hand written C code. There is not much difference, because the Perl core routines are written in C anyway and optimized for that task. If you look at Python, it's again the same pattern. The core logic of some application is implemented in Python and the computational expensive parts are written in C (or even assembler) and called from Python. That's why these languages are often GLUE or SCRIPTING languages.

(+ a b) can be optimized in Lisp. You might not know it, but Lisp has type declarations and several compilers are making good use of it. This widens the range of software that can be written in Lisp. Typically this allows the core logic to be written in plain Lisp and more challenging parts in Lisp with type inference and type declarations - the yet more challenging parts can be written in C or assembler - some Lisps have inline assemblers or inline C - all have extensive interfaces to call routines written to C calling conventions.

I know applications may rely on API calls and may not be computational intensive. This is exactly why Python is not 100-200 slower than C, but only 3-10 times.

(+ a b) can be optimized in Lisp

(a + b) in C is always as optimal as it can be on a given platform. You don't put special effort to make it optimal ("oh, maybe I should declare a and b as typed... let's ask this on the forums if my compiler supports it and in what way").

what is a + b with two arbitrary large numbers in plain C? It can't even add correctly and implements something else than a plain addition. How can it be 'optimal'?

The effect of type declaration on numeric operations is pretty much the same for all Common Lisp compilers that support that. The type declarations themselves are standardized. What is often different is the amount of type inference a compiler does.

    * (defun twice (a) (declare (fixnum a)) (the fixnum (+ a a)))

    TWICE
    * (disassemble 'twice)

    ; disassembly for TWICE
    ; 02AB2CBF:       488D0C12         LEA RCX, [RDX+RDX] 
    ;       C3:       488BD1           MOV RDX, RCX
    ;       C6:       488BE5           MOV RSP, RBP
    ;       C9:       F8               CLC
    ;       CA:       5D               POP RBP
    ;       CB:       C3               RET

You think this will be five times slower than C?

Actually I would prefer C code to be slower and more safe by default. For that I would trade speed in a lot of places.

Fine. Back to the original discussion, I will be left guessing why languages like Lisp and Pascal were left out, even though they may be as efficient as C. Let's say, for example, because of the lack of iPhone-specific infrastructure (APIs etc). Supporting 5 rather than 3 languages would be too much, I guess, considering the 2 are not terribly popular.

Apple is not supporting them anyway. These platforms mostly support themselves.

Guess what, Lisp and others have C FFIs and Objective C bridges and can call Apple's library.

Very very well put.