
Non-Apple's Mistake - zephyrfalcon
http://www.loper-os.org/?p=132
======
cpr
Amid the ranting, he's making a good point.

And that is that there is no serious competition for the hard combination of
serious good taste, obsession with details that seem negligible but ultimately
matter a lot, etc., embodied in Apple's recent products.

I know this sounds like raving Apple fanboy stuff, but I do think it's rarely
acknowledged explicitly; it's either assumed by those in the know, or ignored
by those not.

For example, I would never in a million years want to develop Android
software; why? Because it's written in a language I loathe, and the API is
workmanlike but completely uninspired (disclaimer: I've never written any code
for it). In contrast, the Cocoa Touch APIs are delightful, and MIT-style (vs.
New Jersey) at most levels. Perfect? No. Amazingly crafted? Yes.

I claim the secret sauce to their APIs is actually a character at Apple named
Ali Ozer who, along with his crew, has maintained a firm hand on the tiller,
and learned a huge amount about object-oriented design for interactive systems
over the past couple of decades.

iPhone OS is the result of throwing out a lot of the cruft and starting over,
but keeping the hard-earned knowledge. (Core Animation being one of the key
underlying technologies for iPhone OS that found its way back to the desktop,
but only partially due to all the cruft in normal desktop Cocoa.)

And Apple works hard at the silicon-to-UI whole-stack integration and
performance tuning, something that other vendors famously haven't been able to
do (because they don't control the whole stack), or haven't wanted to do.
Microsoft has recently figured this out, according to Ballmer, and intends to
do the same.

I could go on, but I'm sure I'll get downmodded to death already. ;-)

~~~
vito
The nice thing about Android is you don't _have_ to use Java. Many other
languages target the JVM, which is often trivial to convert to Dalvik (it
depends on the language). Right now I'm working on an entire app in Duby (a
Ruby- _like_ language with static typing and type inference, with no baggage;
reaches native Java speed easily), and loving it. All I had to do was change
my compile command to dubyc and I was ready to go. JRuby is in the works, and
apparently Scala is possible, and I'm sure many others are working on it too.

I've never written an iPhone app, and this is my first Android app, but I find
the API and the SDK to be perfectly easy to work with; it was very easy to get
started and quickly start prototyping. I'd like to know what parts of the
Cocoa APIs you consider delightful though, just out of curiosity.

~~~
WildUtah
Scala and Clojure run like molasses on Dalvik and JRuby will likely be the
same. The Dalvik VM that Android targets is not like the JVM and one of its
deficiencies is that it supports dynamic languages very poorly. Duby may run
fine on JVM but if it's really Ruby-like, it'll be bad on Android.

No. If you want to write professional-quality apps on Dalvik, you'll be
writing in Java or another language just as weak in imagination and
straitjacketed.

Which is not to say that Objective-C is an improvement. At least iPhone apps
used to offer Lua or even Scheme scripting. No longer.

~~~
strlen
Scala is more statically typed then Java. It's _not_ a dynamic language, type
inference (what makes it look like Ruby to some) is done by the compiler.
Modern (i.e., based on concepts dating back to late 70s and 80s instead of 60s
and early 70s) statically typed languages don't have to the have the verbosity
of Java and C++: see F#, OCaml and Haskell.

It does use reflection for certain types of pattern matching (only similarity
with the JVM dynamic languages), but I'd expect most of the issues (note: I
haven't tried myself) are due to the Scala compiler specifically targeting
HotSpot.

~~~
bad_user
> _Scala is more statically typed then Java._

Being a contrarian here :)

It doesn't matter how static Scala or any other language is, all that matters
is how well its type system fits into the target VM, and Java VMs are
optimized for Java.

When the type-system doesn't fit you have to resort to workarounds, like
allocating more objects than you should, or using introspection, or generating
bytecode at runtime.

The JVM does fine here, but Dalvik is a VM created for a restricted
environment.

That said, I don't think static languages should have problems ... as long as
they don't stray too far from Java ... like being lazy or having type-classes.

> _Modern ... statically typed languages don't have to the have the verbosity
> of Java and C++_

They don't have subtype-polymorphism either (basically OOP).

Since you mentioned OCaml and F#, you should take notice that the OOP subset
doesn't support type inference when you're dealing with interfaces, that's
because it is not possible. OOP was designed for dynamic type-systems, and it
mixes with static typing like oil and water.

Also Scala's type inference is really restrictive and should't be in the same
league as any other language with a Hindley-Milner type inference system.

The type inference is really useful when you're dealing with parametric
polymorphism. Scala doesn't really have that either ... generics only save you
from explicit type-casts, nothing else, and are a far cry from Haskell's type-
classes or C++'s templates (which are late-bound). The recently introduced
Manifests or the implicit conversions save you in many cases, but those are
just ugly hacks that only solve certain use-cases.

I really don't get why Scala is so popular. It's as if people are so tired of
Java that they are looking for a way out, willing to compromise just for some
syntactic sugar.

It's interesting to note that none of the issues of subtype-polymorphism
(tight coupling) or those of parametric polymorphism (hard to get right) are
of importance to _dynamic languages_. In a dynamic language polymorphism is
simply implicit.

That's why I hope people will invest in VMs that support dynamic languages in
the future ... static typing is a bitch to get right, and it would be easier
if the VM wouldn't impose a strict type-system on you.

~~~
strlen
First, this is an excellent comment and should have a much higher score than
my fanboyish original :-)

I agree that Scala is restricted by the JVM (and the aim of full compatibility
with Java) and as a result type inference, pattern matching and more suffer
heavily. F#, OCaml and Haskell are better examples of modern type systems as
they're less encumbered. I am fairly curious about how F# works around the CLR
(or rather, how much CLR accommodates type systems different from C#'s), guess
it's up to me to RTFM.

 _> It's as if people are so tired of Java that they are looking for a way
out, willing to compromise just for some syntactic sugar._

I think this hits the nail on the head, but I don't see it as a bad thing. If
there's a very strong reason to be on the JVM (e.g., other projects or
libraries, operations preferences), it's nice to have an option that lets one
have a more productive and enjoyable experience.

There are times where it feels like a big compiler hack (which it is), but
first class functions (even if they're compiled down to anonymous classes),
closures, optional lazy evaluation, type inference, limited pattern matching,
case classes, traits/mixins, "encouraged" immutability, the collections,
etc... add-up.

There are occasionally bugs and performance issues with compiler and the
collections library, but overall I don't see what's compromised compared to
programming in Java itself. I'd argue syntactic sugar classification applies
more to Java 7's planned closures and first class methods.

 _> OOP was designed for dynamic type-systems_

Yes, that's _literally_ true. OOP feels natural in dynamically typed
languages, even when it's bolted on (CLOS in Common Lisp, Perl 5).

It's still a mystery to me why Java "won over", given that Smalltalk had (at
the time) better performing virtual machines (compared to older JVMs which
were superceeded by HotSpot, which was originally used by Strongtalk) and
great tooling. There are known examples of teams of inexperienced programmers
working under guidance to produce large, well working projects in Smalltalk.

 _> That's why I hope people will invest in VMs that support dynamic languages
in the future ... static typing is a bitch to get right, and it would be
easier if the VM wouldn't impose a strict type-system on you._

Clojure, in my view, suffers the most from the type system that the JVM
imposes. It would be interesting to see if Clojure and Scala would eventually
target less restrictive VMs (reverting to compiler hacks on the JVM to
functionally emulate these VMs).

~~~
WildUtah
_It's still a mystery to me why Java "won over", given that Smalltalk had (at
the time) better performing virtual machines (compared to older JVMs which
were superceeded by HotSpot, which was originally used by Strongtalk) and
great tooling._

It's very simple. Smalltalk was expensive. Students, hobbyists, people working
at cheap corporations, startups, open source projects, and the like couldn't
write, share, and distribute working systems on it.

I understand there were some good vendors with steep student discounts and the
like. My roommate loved some of them. But he could not hack with friends for
free (or even very cheap) on it.

And that little bit of money makes all the difference. Not that it would have
taken off otherwise; there are many factors, but no language or VM that
charges for access has taken off in a generation except where access to
hardware is strictly limited by law (smartphones) or expense (FPGA, large
scale microcontroller projects).

~~~
stcredzero
_It's very simple. Smalltalk was expensive. Students, hobbyists, people
working at cheap corporations, startups, open source projects, and the like
couldn't write, share, and distribute working systems on it._

In fact, it was the deliberate strategy to become a "boutique" language, a
secret weapon of the Fortune 500. The Smalltalk companies missed out on "The
Bazaar" and the mindshare benefits of an open community.

------
notauser
To pick one particular nit:

 _The fabled Google Android? It is entirely the piece of junk one ought to
expect from a development process driven by committees and steered by non-
creative minds. And it appears that many would-be buyers know it._

The actual numbers are around 100k/day (iPhone) vs 60k/day (Android).

Considering that Sony Ericsson and LG still coming up to speed, so those sales
are mostly HTC+Motorola, that's pretty impressive.

It's also missing the point that others are free to design their own UI on top
of Android and indeed the big players are. Sense (HTC) is really rather nice
and definitely doesn't feel like it was designed by a committee.

 _Edit: Here's a source for the sales
numbers[http://industry.bnet.com/technology/10005344/android-unit-
sa...](http://industry.bnet.com/technology/10005344/android-unit-sales-
catching-iphones/) \- I'm afraid the opinion about Sense is just my own
personal view._

~~~
danudey
_It's also missing the point that others are free to design their own UI on
top of Android and indeed the big players are. Sense (HTC) is really rather
nice and definitely doesn't feel like it was designed by a committee._

But this can be a downside as well. You say 'Android' and people associate the
one with the other, but there are a multitude of 'Android' devices which are
either inherently incompatible
(<http://news.cnet.com/8301-17938_105-20002508-1.html>) or whose basic
interfaces are different enough _because_ of that customization that it can be
confusing to initial users.

Also, the fragmentation of Android by hardware leads to fragmentation by
software. Software designed for too large of a screen might not work on
smaller screens. Software designed with a hardware keyboard in mind might not
work on the onscreen keyboard.

People are still selling Android phones with version 1.6 on them, which won't
run software requiring newer versions (which software won't show up in the
marketplace at all, confusing users).

Customization is great, but by not mandating any sort of rules, the market is
getting fragmented in a lot of different ways, and people are just going to
get more confused, presented with an overwhelming list of options. This one
has a hardware keyboard, this one has better GPS, this one has newer software,
this one is faster, this one has a higher-resolution screen. The very purpose
behind Android - customization, distinguishing yourself from the competition -
is what fragments the market.

Apple's approach, however, is very simplistic. Here's the iPhone. How much
storage do you want? 16GB? Ok, here you go. Apps will work. Accessories will
work. Cables will work. Cases will fit. There's little to no confusion for the
user.

That seems to be what the original article is suggesting. Simplicity and ease
of use that starts before you even make your purchase.

~~~
notauser
_People are still selling Android phones with version 1.6 on them, which won't
run software requiring newer versions (which software won't show up in the
marketplace at all, confusing users)._

This is the same for the App Store and firmware upgrades, and is a good deal
more sensible than the alternative option of letting people buy/install
software that won't work.

~~~
irons
It's not remotely the same. All iPhones made to date run the current OS, and
are prompted to upgrade to it when users activate their phones or sync their
music libraries or back up. Android's OS is upgraded by the carrier; most
carriers aren't even a little bit interested in doing it; the few that are
interested spend more time dithering than Google spends cooking up each new
release.

Meanwhile, iPhone OS 4 will support all phones except the first generation
(even if the second-gen phones won't support multitasking, they'll still run
the third-party apps). No comparable statement can be made about any Android
OS release, referring to handsets of any age, from any vendor.

------
vtail
It seems that most people's strong reaction to Apple's decision is not _just_
because it's a mistake (which I think it is), but because it directly affects
their life _and_ there is no serious alternative to avoid the consequences.

Example: I don't really care what restrictions Microsoft will impose on
developers for its next phone OS, because I don't care about their products.
It does matter for me, however, that Lotus Notes design is horrible (and
getting worse with every version), as that's what I'm forced to use at work
and there is no alternative for me.

If HTC/Android were such a strong alternative to iPhone/iPhone OS, most
developers would simply ignore Apple's move: "They made a stupid decision?" -
"Very well, our community and market share will grow as a result".

Unfortunately, as Stanislav notes above, for many developers and users there
are not many alternatives to the iPhone, with it's high quality design and
strong eco-system.

And that's what makes people furious.

~~~
gamble
Exactly. The real problem with the anti-Apple arguments is that - for the
moment - Apple's behavior hasn't hurt them. The iPhone still has more apps,
and iPhone owners are far more likely to buy apps. The Android app store is
still a wash, despite all Android handsets sold this year.

I think that in the long run Apple's App Store policies would hurt the iPhone
if they weren't willing to make the platform more open, but the walled garden
approach probably makes more sense while the public is still getting used to
the idea of mobile applications.

Apple deserves some credit for persuading people to actually pay for software.
How much does the average person spend on third-party software for their PC?
Judging from how much shelf space Best Buy devotes to PC software, I'd bet
it's pretty small compared to what people are spending on apps now.

------
grellas
Human creativity can never be bent over a sustained period to the will of one
man, however gifted and prodigious he may be, and especially in an area so
vast and fruitful as that of digital creativity. That is why Steve Jobs, all-
powerful as he may be today, will (if he is not careful) watch developers
gleefully flee from his grip as occasion permits at some point in the future,
or from the grip of his company if he is no longer around to affect the
outcome directly.

I am not a developer and I do not pretend to know how developers think but I
_have_ worked with countless developers over the years and still remember them
chafing, for example, under Microsoft's sway in the 1990s even as they were
forced to conform to its arbitrary and often harmful edicts and dictates that
so affected their financial well-being. Well, Microsoft got away with it for a
long time but burned its goodwill in the process (Microsoft had goodwill? You
bet. In the 1980s, developers were tripping over themselves to get their new
apps out in sync with Microsoft's initiatives and a regular amen chorus would
sing Microsoft's praises at every such step - with a breathless _PC Magazine_
and many others waiting to review every step and a herd of authors primed to
write about them).

Today, Apple is dominating in an analogous vein and getting away with it, but
it too is beginning to burn the goodwill it has had over many years with
significant groups of loyal developers who now have no choice but to adhere,
however grudgingly, to the ever-changing and seemingly capricious guidelines
and restrictions being imposed upon them by Apple in hopes of continuing to
build their companies or preserving their livelihoods. Perhaps its all-
controlling policies will prove benign and wise and will only serve to
maintain quality on its various platforms, as the company and its apologists
contend. If, however, Apple is instead headed down a more nefarious path,
there is nothing that will eventually shield it from the resentment and
abhorrence it will face from developers as it burns goodwill with each step it
takes in that direction.

It was precisely those loyal developers who carried Apple through its darkest
days, when by all accounts it should have failed as a company, and it will be
precisely those developers who will in time be nowhere in sight should Apple
permanently burn them.

------
barrkel
I'm not sure why "Microsoft free" is a product category? I mean, if you start
out from such an odd ideological position, there's no telling what else you
can convince yourself of.

~~~
pohl
The tacit claim that you're making here is that ideology is the only possible
reason that one might have for wanting to avoid any particular vendor. Maybe
you need to support that claim a bit. Surely a company of their magnitude has
a healthy share of run-of-the-mill disgruntled former customers.

~~~
wmf
While there are legitimate reasons to avoid MS products, it's lazy for the
author to say "Microsoft-free" without explaining why. Also, it may not be
wise to hold grudges when the original reason is gone (e.g. Win7 is a lot
better than old Windows).

------
api
Words cannot describe how right he is.

Apple is becoming an 8000 pound gorilla because _nobody else can design a user
interface!_ Windows is crap committee-ware, and open source UIs insist on
imitating Windows (look at Gnome, KDE) which means they're imitation crap.

There are other aspects to Apple that matter too. Their code performs well and
doesn't tend to break. There's a polish that Apple's code has that nobody else
puts on their product.

Their hardware is decent (not excellent, but decent) on the quality factor
too, but it's also well-designed just like their UIs are. The biggest feature
of Apple's hardware is what it doesn't have: loads of useless buttons (stupid
blue ThinkVantage button, I'm looking at you!), connectors you never use, etc.

Note that Linux rules the server space for the same reason. Open source UIs
are crap, but _under the hood_ the open source ecosystem obviously cares. So
in markets where under the hood matters most, Linux and other OSS operating
systems are the dominant players.

The moral of the story?

Stop listening to the idiots that tell you that the way to design software is
to slap it together and focus exclusively on marketing. This only works if
your market is not crowded. This worked for Microsoft in the 80s and 90s
because there weren't many affordable alternatives.

People actually do care about quality.

~~~
jon_dahl
Apple's aesthetics are important, no doubt. But equally important was its
decision to _standardize_ its computers on BSD and Intel. Before OS X, Apple
was a niche product, and its niche didn't include most developers. After OS X,
the dev community started to trickle in, but it really took off after the
Intel switch. Partly because the Core Duo was much faster than the PowerPC,
but also because the PowerPC was a form of lock-in. It kept good software out,
and made it hard to develop for other platforms.

Apple owes a lot to standardization and opening up. It's not all App Store
lockdown. The question is, is this App Store crap a general trend? Are they
going to bring that to the desktop?

~~~
baguasquirrel
Others could have done the same. BeOS didn't succeed. You don't see Linux
everywhere and it was (and still is) based on openness.

~~~
DrSprout
But you do see Linux everywhere. Servers, embedded devices (including Android)
tons run Linux. The Desktop is just a sliver.

------
alanh
Oops, we're all spambots now: <http://www.loper-os.org/?p=91>

------
jrockway
_No one else makes a portable where every hardware component simply works,
including suspend mode, while entirely freeing me from Microsoft._

Uh, everyone makes this? All decent laptops are Centrino these days, and guess
what, all that hardware works fine under Linux. I haven't owned a machine in
years that wasn't perfectly supported by Linux.

Suspend / hibernate also works fine with modern BIOSes.

~~~
asciilifeform
> Uh, everyone makes this? All decent laptops are Centrino these days

Which laptop maker will sell a machine where _every single hardware component_
is guaranteed to work _perfectly_ under Linux? Without endless driver-hunting,
Dependency Hell, crashes, and "small" but intolerable imperfections.

My Centrino-based Thinkpad (circa 2007) failed to properly suspend the video
chip under a perfectly-configured Linux, draining a freshly charged battery in
only twelve hours. Note that I do not care if this (documented) bug has since
been fixed. Neither do I care just who was at fault (the chip vendor, for
failing to release docs; the slacking developers; the devil - I simply don't
care.) Such cases are rampant, the culprits are unrepentant, and there is no
vendor which will offer a money-back guarantee of nothing of this kind
happening.

> Suspend / hibernate also works fine with modern BIOSes.

Which ones? Is this authoritatively documented anywhere, in real time? What is
"fine"? Apple-fine, Microshit-fine, or sea-of-hacks-Gentoo-fine?

------
nnutter
He's right about how Apple got here but now that it's #1 they are using
contract law to maintain a monopoly. No less evil than Microsoft at its worst.

------
joe_the_user
Amazing article, raises crucial questions.

 _What is to be gained from corporate sainthood? From a refusal to fleece
eagerly willing suckers for all they’re worth?_

Long-term Loyalty of those who matter? It's a question worth pondering.

The point that Apple rests on _good protocols_ , from GUIs to APIs is also
key. I don't think that only Steve-Jobs-like-management produces such things
but the need for a protocol spring-forth from a consistent idea is absolutely
crucial. It has happened in past - the Ruby language is cool example (and it's
not a coincidence that Ruby is more or less the _idea_ of Matz but it can be
the idea of Matz without us suffering the dictatorship of Matz). Especially
for open source development, we should be asking how we can duplicate that
process at a high level - and not copying friggin awful GUI elements from
Aero.

------
stanleydrew
This seems a rather trollish article. Sadly hn appears to have taken the bait.

------
drivebyacct
This article is simply obnoxious. Pathetic ramblings about how great and
unique Apple is just because he doesn't like the software offered by Microsoft
or the hardware offered by its competitors. Then just cheap, inaccurate,
unarticulated attacks on Android.

~~~
technomancy
That's par for the course for this guy. No surprise here.

------
voxcogitatio
It continues to amaze me how many and adamant apple's apologists are.
Stockholm syndrome?

------
mattmaroon
This is silly. I could take a dump and then say I have a monopoly on things
floating in my toilet. It's true, but meaningless.

Most people don't desire to be "freed from Microsoft". They don't give much of
a damn one way or the other. They want a $600 laptop so they can check their
Facebook page. If having a monopoly on something only some tiny % of users
(not even all Mac users, which is 5%) care about ever becomes illegal, I'm
expatriating.

Legally speaking Apple is doing nothing wrong. And ethically. Whether their
walled garden approach is a solid business decision remains to be seen but
it's not monopolistic.

Other companies do make great CE devices. Ignore phones (a topic about as
fruitful to argue over as religion) and you can probably think of 10.

