Hacker News new | past | comments | ask | show | jobs | submit login
Electron apps cannot be submitted to the Apple store (david.dev)
395 points by rdevnull 13 days ago | hide | past | web | favorite | 428 comments





The basic concept isn't too disturbing; Apple packages private APIs that have no guaranteed behavior or expectation of support. If you depend on those APIs, it's very possible that your app will break in a future OS update.

This is conceptually no different than calling something in the sun.* packages in Java. For years it was ok, and then ... it wasn't.

This, however, is draconian:

> Continuing to use or conceal non-public APIs in future submissions of this app may result in the termination of your Apple Developer account, as well as removal of all associated apps from the App Store.

"Keep trying to submit, and we might just ban you forever" is insane. Every program of any complexity depends on third party libraries, and many people wouldn't be able to tell what arcane APIs their dependencies (or their dependencies' dependencies) call. "If you continue to have an upstream dependency that violates our terms, we might permaban you" is bullshit.

It's also completely unsurprising. Apple has no love nor concern for their developers anymore. It used to be the premier development platform in the world. Now it's ... I don't even know anymore.


Getting out of iOS development and back into web dev was the best career decision I ever made. I feel like I escaped an abusive relationship. So much of what's wrong with computing and tech right now stems directly or indirectly from the culture at Apple.

It's funny how the general consensus on here is against Microsoft's abuse of private APIs in Windows to help Word and DOS against WordPerfect and DrDOS, 20+ years ago. But Apple doing it right now in a much worse way is considered acceptable and defendable.

I don't think anyone here considers Apple's abuse of private APIs vs developers an ok thing. I will never subject myself to their app store if I can help it.

I think it's more a case of people just being unaware. They might have an idea that this is going on, but because they've never run into it it's not something that's a priority. I'd even wager that the vast majority of non-Americans here don't use Apple hardware.

I'm fairly sure a number of App Store developers browse Hacker News.

Many of us frequently subject ourselves to all kinds of abuse that we don't consider an ok thing.

It's shameful but eh, it's a living.

https://www.youtube.com/watch?v=pyxJ7GKGFG0


This is a straw man argument. Who is making that point?

In general, I find the opinions on these things to be pretty consistent: the “free market” types tend to support Apple/MS - usually with some form of “its their platform” as an argument - and the FOSS types holding the opposite position.


Walled gardens weren't as normalized then.

I got the first warning sign that I was entering into an abusive relationship early on in 2007 when I tried to sign up for the Apple Developer Program from Europe, and Apple INSISTED that I FAX my developer program application in to them.

I work in public digitisation and while we don’t build the apps, we’re now required to publish them if we want our name as the publisher. So I’ve had the pleasure of setting up our development account and it’s easily the works service I’ve ever had to go through, and we operate 300 different IT systems, some are old terminal systems that run on mainframe.

I’m not sure why the process was so complicated either. A couple of steps involved Apple calling me, and my superior, to verify that we were real. Except they didn’t actually verify that, because it was a simple conversation and I could have just lied with a buddy of mine... Even adding developers from our suppliers was a tedious process, and of course Apple has no way of integrating with our IDM or local security setups.

They sure are lucky to have a monopoly on iOS devices.


> we’re now required to publish them if we want our name as the publisher.

That seems reasonable to me -- they're just saying that if you want to be listed as the publisher, you need to be the publisher...


Sure, but that’s not actually what happened. I didn’t go into detail with that part, because it’s fine. We’re fine with someone else being the publisher and listed as such though, but you’re not allowed to do that on behalf of others anymore.

The result is 98 muniplacities having to pay Apple developer fees, but it gets better because the app can’t be called the same thing anymore. So now there are 98 apps instead of one. :p

I mean, I guess our central digitisation agency should really just pick it up, but the bureaucracy doesn’t work like that.


Forgive me if I'm not understanding correctly, but in your description here it sounds like the problem is in how your organization functions around this, not in Apple's policies.

It's not really fair to expect Apple to resolve or work around your own organizational problems.


Why not? Microsoft does it all the time. So does Google, to an extend.

Apples inability to work with us is the primary reason we replaced thousands of iPads for school children with Chrome books. Eventually Apple caved to our needs, but it was way too late. Google were “what can we do to make this deal work for both of us?” from day one.


If a company is willing to do that, hooray!

What I'm saying is that it's unfair to expect it. As in, if a company is not willing to bend over backwards for you, it's not fair to condemn them for that. It's totally fair to praise their competitors who will, though.


I wouldn’t mind I had options, but I don’t. Instead we’re the ones to bend over backwards, as you put it, because Apple has a monopoly that we’re required to use.

Grass is always greener :). After years of webdev and js madness I've found a recent iOS development project to be a welcome break.

What's bullshit about banning someone who has been notified that they are in violation of the rules and then tries to hide their use of private APIs rather than stop using them? That's exactly what I would do in Apple's position. Resubmitting the same thing and hoping that it doesn't get caught the next time isn't an honest mistake.

> then tries to hide their use of private APIs rather than stop using them [...] Resubmitting the same thing and hoping that it doesn't get caught the next time isn't an honest mistake.

This is missing the point of the post you are replying to. Say you identify five closed API dependencies and remove them. Do you resubmit? If you missed any others, you and all your apps might be banned.


They do not ban you for removing some uses of private APIs, but missing others and resubmitting. In the last decade of this being the policy on the iOS app store they've been quite consistent about only banning people who very clearly are deliberately trying to sneak things in.

> They do not ban you for removing some uses of private APIs, but missing others and resubmitting.

Maybe not -- maybe you know something about how Apple operates. But clearly they ARE sending responses threatening to do exactly that.


> maybe you know something about how Apple operates

Anecdotally, I have never heard of this happening in non-malicious cases, ever. And I know a couple hundred Mac and iOS developers who would raise a lot of noise if this did happen, so I'm inclined to believe that it doesn't.


Because in the past, developers have obfuscated their use of private APIs rather than removing them. They are threatening to ban people who abuse the platform. They aren't going to ban anyone making an honest effort to eliminate their use of private APIs.

Where as on Windows there is no such issue.

Yep - instead, Windows is dragged down by 20-40 years of bug-for-bug API compatibility, even in the things that were never documented as public API and pretty clearly look like internal solutions that the author at Microsoft never designed for public use.

There is a good reason for how Apple approaches use of their private APIs, and for how Microsoft approaches use of their private APIs. Not saying either one is correct, there really is no answer, but consider that for any public API that exists, there may be undocumented details that some software somewhere relies upon whether they realise it or not. Apple is just taking a more aggressive approach than Microsoft here by detecting and disallowing private API use in their store so as to avoid issues down the line.


As far as I know, the Microsoft Store has a similar-sounding check for "unsupported" APIs. I don't know the details though.

[1] https://tedwvc.wordpress.com/2013/07/19/finding-the-kernel32...

[2] https://github.com/golang/go/issues/21805


There's no issue here for a Mac either (this was for a submission for a macOS program). The problem was when submitting it to the Mac App Store.

They can ban you for absolutely any reason whatsoever. They can ban you for using the number "4" in your code.

They don't, though. And we trust them not to, because it is not reasonable behaviour and it would absolutely not make sense for them to do this.

This is the same.


Yes, you resubmit.

How exactly do you miss a dependency?! If it's not your code, then it's a dependency that you need to look at.

Dependencies of your dependencies! Imagine installing a library that depends on a couple dozen libraries in its own right. You may not have time to inspect every single node in the dependency graph.

As an end user, can I just say how uncomfortable I am at the idea that some app on the App Store includes some node.js dependency where the app developer has no idea what's in it? What if it's event-stream?

If you're sending me code to run on my computer—especially if I'm paying for it—you either need to have glanced at the code yourself or have some reason to trust what's in there (it's from a company you have a business relationship with, it's a major library from a known author that other apps on the store are also using, etc.). Otherwise you're being irresponsible. If you don't have the time to look at the library, don't use it.


I'm a developer, and knowing how this is the default is not something I particularly like, but it's really only in the most security/mission critical code that dependencies get thoroughly wetted.

You can fully expect that less then 1% of the apps in any app store has a transitive dependency chain that is fully known and understood by the author to any meaningful extent.

Most of that code is however understood by someone, although not necessarily the app developer. The sandboxing and app permission dialogue boxes are unfortunately a critical part of the defense against malicious code, although not a perfect one by any stretch of the imagination.


So never run Linux?

I get Linux from people I trust to verify source code and the source code of dependencies and to push back against dependency sprawl (Debian, in my case, and I'm on debian-devel and I happen to see every email sent for every new package; there's an overhead there). Others get Linux from a vendor they have a commercial relationship with (Red Hat, Canonical, even Oracle, etc.)

So, can you expand on why you think one should never run Linux?


Or only run Linux? *

* (any source available OS)


GP says not to run anything you haven't looked at yourself for the most part, paraphrasing. I doubt anyone has self audited all the software and drivers going into a desktop Linux distro.

The point is, at some point you stop digging


> GP says not to run anything you haven't looked at yourself for the most part, paraphrasing.

That is a highly inaccurate paraphrase of what I said. You can tell it's inaccurate because I'm specifically suggesting that end users should be able to trust apps on the App Store without auditing the apps ourselves, as long as we trust the app authors, and that app authors should bear responsibility for what they redistribute.


Desktop Linux distros have package maintainers and companies behind them like RedHat or Canonical.

GP says not to publish anything you haven't looked at (or OKed by appeal to authority). Publishing should be a higher standard than running.

> Dependencies of your dependencies! Imagine installing a library that depends on a couple dozen libraries in its own right. You may not have time to inspect every single node in the dependency graph.

Excuse me, are you, the developer, telling me, a user, that you don't know what you're giving me to run on my computer?


Hi my name is node_modules have you met me? If you invite me to a party I bring my 500 closest friends as my plus one!

I just looked at the node_modules folder for a project that runs user configured code when your imap server gets a new mail via imap idle. It's called imapnotify and inside its node_modules dir I see it pulls in 549 js files.

The majority are under 100 lines per file dozens are between 1 and 30.

Cutting just the last segment so that /foo/bar/baz.js and /bam/baz.js both appear as baz.js and removing dupes reduced the number of unique filenames to 383.

Basically every js dev is either telling you or not telling you that they don't know what they are giving you to run on your computer.


There are reasons forums known for being less diplomatic than HN often take delight in heaping scorn and ridicule on js devs. This is one of those reasons.

> If you invite me to a party I bring my 500 closest friends as my plus one!

That sort of thing is a big red flag that perhaps you should reconsider using that package.

But even if you do use it, that in no way reduces the fact that it's your responsibility to know what you're shipping.


That is every javascript package ever incidentally. Do you have an alternative suggestion as far as connecting to an imap server and responding to events? Not a library to write such a thing but an actual implementation.

No, I don't, but even if there are no such alternate packages, that doesn't mean it's OK to use one that you can't sufficiently understand.

If you can't find an acceptable package, then I'd absolutely recommend writing that functionality yourself. connecting to an IMAP server and responding to events aren't complicated tasks, after all.


This is entirely feasible but what percentage of people can write replacements for problematic tools and what tools can they afford to replace time?

Among software engineers? I would expect (hope?) that the percentage that could do this approaches 100.

How much extra time do you have to reimpliment things that work because you disagree with how they are written?

You misunderstand what I'm saying. This isn't about disagreeing with how anything is written, this is about the responsibility of developers to know what they're shipping.

If devs can't do things like be able to tell what dependencies a module/library has, then they shouldn't use that module/library.


With NPM as an example to fully know every dependency is a highly time-intensive and complicated task due to following:

* you can't be sure code in package is same you see on github as npm doesn't do signatures

* code already in node_modules is usually minified and obfuscated

So only real way to be sure is to make own repository, copy every dependency, check code, build own packages and only use packages from your repo. Repeat process when versions are updated.

So to answer your question, yes, 99% of apps, they don't know.


That's an excellent reason to avoid using apps.

I think that ship sailed a long time ago. Right now I'm building an app with Google's mobile toolkit, Flutter. Flutter itself is a few hundred kloc. And on top of that, I'm using a bunch of libraries; I wouldn't be shocked if it were the same amount of code again. Assuming I can properly code review a few hundred lines per hour, reviewing all that will take me a year or so. Which is maybe 5x what it will take me to ship an MVP.

You are missing the fact that dependency tree is constantly changing as dependencies get bug fixes and security patches, so in the middle of your review you will be forced to re-check.

Unless you are willing to freeze whole tree until review is done but then you don't get bug fixes and security updates for period of initial review + review of updated packages.


Is that a joke? Surely you aren't suggesting that developers should have full knowledge of all transitive dependencies that compose their application stack.

> Is that a joke? Surely you aren't suggesting that developers should have full knowledge of all transitive dependencies that compose their application stack.

This will be borderline impossible for a nodejs developer, but a perfectly realistic expectation for e.g. a Django project.


For licensing reasons alone, almost got hit by one dependency switching from LGPL 2 to GPL 3 and one project we bought dropped dead once someone went over its dependency tree and noticed the mess of highly incompatible licenses, it would have taken years to get to a point where we could legally publish anything. Not knowing about all of your dependencies is a liability.

Not full knowledge. But you should know about every single dependency, know what they do and if they're from a trustworthy source. Being able to say with confidence that you aren't installing malware on your customers machines is the least you can do.

On the developer side there's more though, you should know what their release cycles are like, how they manage compatibility, how long they support older releases etc. You don't what your app stuck in a 3 month upgrade cycle just because a transitive dependency needed an update.

There's a reason dependencies are there own form of technical debt and need to be minimized.


Knowing every transitive dependency in your application stack is totally unrealistic and is pretty much impossible for any modern commercial software outside of specialized/embedded systems.

Having knowledge of every dependency explicitly linked into your application is a basic tenet of software development that literally every software professional would endorse as a necessary best practice, but it's not what we're talking about here. I am 100% certain that every developer with a commercial Electron app is aware that they are relying on Electron as a dependency and Github as a trustworthy software vendor.


> outside of specialized/embedded systems.

I think you're conflating platforms and dependencies. The OS it runs on is a platform that the the user already trusts, left-pad is a dependency the developers are responsible for. There's some grey area like electron or the JVM but even there electron sticks out as a huge binary blob the user isn't explicitly asked to install.


I never brought up operating systems in the context of this discussion on dependencies. Electron is not an operating system, so I am not sure what your point is.

Chromium and also Electron are trustable sources. Besides that any Mac OS X App from 10.15.1 (Catalina) has to be notarized. I got the dmg notarized so I know that the malware is not the issue. Now asking every ElectronJS developer to know every single part of Chromium or even electron itself is a bit unreasonable.

as CTO I know all the dependencies in the application stack of our company and I require developers to have sufficient understanding of their purpose, licensing model etc. There are tools to simplify this task. It’s much harder to do for TypeScript than for Java, mostly because NPM ecosystem is a huge pile of junk, but it’s still important part of developer's job.

> as CTO I know all the dependencies in the application stack of our company

You know all of the transitive dependencies in the application stack of your company? Out of curiosity, what is the ballpark figure on the total number of transitive dependencies in your application?


Hundreds, mostly because of the JS nonsense. Our Java microservices are lean and strictly controlled.

as CTO I know all the dependencies in the application stack of our company

I'm a few years out of the Java world these days, but you've vetted every line in every one of those Apache commons projects that gets pulled in? Because that's a lot of reading...

Over 10 years ago I went through every single Java RSS parsing library and all their forks (I think there were 5) to fix Xml eXternal Entity (XXE) attacks (eg[1]) and submitted fixes for them all.

That was a huge amount of work, because they all used random version of different XML parsers, all of which required external entity processing to be turned off in different ways.

None of the authors of the packages were aware of the issue, and as far I could determine at the time I was the only person in the entire Java ecosystem who knew all the different parsers arguments.

This was a critical, remotely exploitable vulnerability. I'd never claim to know about it now, and it was only for a few weeks back in 2006 that I really knew it then.

So when you say you "know" all the dependencies in your stack, what do you mean exactly?

[1] https://rometools.jira.com/browse/ROME-46


We barely have any of the Apache commons dependencies - in most cases use of them is not justified in modern Java. If there’s anything like that we are ready to support such dependency on source code level, patching and setting up own build pipeline if necessary. Free software cannot be trusted if you are not ready to own it. Commercial software cannot be trusted either, but there are other ways to manage the risks there.

I can't believe you check all the source code, dependencies source code and the rest of the shit show that npm brings to the party, that's very cool, all CTOs should be like you. As a CTO should you have to do this though? I'm not sure.

We are growing startup and it’s important to have this culture of understanding what and how you build from the very beginning. This responsibility is now transferred to technical leads, but I’m still aware of what’s going on and spend some time on the code reviews.

How much time does it take to read through the millions of lines of code?

Usually you don't write a project and then sit down to read through all dependencies, but it's a process that happens when you do add a dependency.

So, the process would be something like: have a problem that a library might solve, find a library that could solve the problem, verify it can solve the problem, look through the implementation, look through it's dependencies, then actually include it in the build. If anything doesn't look nice at each step, rollback and find something else or start writing your own implementation.

Do this from beginning of the project and you'll always have a full understanding of the system.


Honestly, it boggles the mind to think that a responsible developer would just pull in some 3rd party dependency without auditing what it does/calls and what other sub-dependencies it has, and then ship it as their product that their business relies on.

Everywhere I’ve ever worked, adopting a dependent library was a HUGE DEAL. You don’t do it lightly. You have to know what’s in it, know what it calls, know what the license is, understand the increased security attack surface, measure how much bigger it makes your binary, measure any performance deltas, and so on. In bigger companies, you need to get all sorts of approvals... Who the heck are these companies where you just hook up the git submodule and wing it?


Can you even know every transitive dependency in an average Node.js project? I just looked at a simple web service we have, which doesn't use any framework or such, and it's 5 dependencies pull in 75 dependencies altogether.

Since most applications nowadays are server side, you would usually already pull 1 GB+ of Docker layers, before you even add application + libraries.

Facebook on iOS seems to be around 400 MB of size (first result from quick googling, might be wrong), and average Electron app is 120 MB+, so I don't think the size is a huge concern.


I do know just that for apps I ship.

I will never in a million year ship anything on, for instance, node.js, for exactly this reason.


I think that's not an unreasonable thing to expect at all. If the libraries you're using make that impossible, then you shouldn't use those libraries. You should know what you're shipping.

As a developer, I'm honestly and utterly stunned to see other developers arguing otherwise.


It's going to sound uncharitable, but if you're clearly being rejected for something that your dependencies is doing wrong you should make time to figure out which one it is.

Is it really difficult to find private API usage? Can they be searched for through static or dynamic analysis?

I don’t develop for iOS so I’m genuinely curious. Do they provide automated tools for developers to use? Or a flag that fails your build if you’re trying to call private APIs: For that matter, how are the reviewers catching these API usages?

I find it strange that a private API can be used accidentally, without something notifying the developer before they’ve gotten to the stage of submitting their app.


> I find it strange that a private API can be used accidentally, without something notifying the developer before they’ve gotten to the stage of submitting their app.

It's difficult to use private API accidentally. However, it is possible to use a dependency that purposefully uses private API, which is what happened here.

> Do they provide automated tools for developers to use?

No.

> Or a flag that fails your build if you’re trying to call private APIs

Kinda, but that doesn't help you if your dependency is trying really hard to use that API and has been precompiled.

> For that matter, how are the reviewers catching these API usages?

They're running somewhat stupid static analysis and possibly some dynamic analysis? They don't tell you what they do but they're not very good at it and don't generally catch even basic obfuscation. However, if a human finds your private API usage and you look like you're trying to obfuscate it, they won't be nearly as lenient.


Yes, as indicated in the OP you can use otool to see which private APIs are being called.

Your dependencies (including the transitive ones) are your responsibility. If you can't keep track of them, perhaps you fucked up. https://queue.acm.org/detail.cfm?id=3344149

> You may not have time to inspect every single node in the dependency graph.

You may not have time to do your job properly?

If you're using libraries in your project, it's normal and expected that you know what those libraries are doing and what those libraries depend on. You should know this stuff regardless of what Apple (or anyone else) may require.


Have you never run maven, sbt, gradle on a Java project, or PHP compose or .. anything in node? There are so. Many. Dependencies in some of the frameworks people commonly use. It can get pretty insane. We all remember left-pad, right?

Lack of knowledge of your dependency tree isn't really an excuse here. If you're submitting your application to an App Store -- where one of the express purposes is that customers know the application is safe -- then having an unknown dependency is not really a good argument.

How are you sure that your code gets compiled properly? Do you read the assembly generated for the processor and the source code for your compiler?

Are you sure that your machine code gets run properly? Do you test the CPU hardware and all the logical gates and whatnot so that they respond to the schemes and it passes the electric current properly?

Like xkcd 378, we could follow this logic quite deep. At some point you just have to trust, or at least assume that something is going to work, without properly verifying it yourself.

Smarter people than me have essentially dedicated their life to some extremely specific area of computing. It's not reasonable to assume that I could and should deep-dive into every possible nook and cranny just in order to build an application. I already have to do a whole lot of assumptions because of my hardware used for development, my OS and software tools like my IDE, task runners and yes, external libraries.


> It's not reasonable to assume that I could and should deep-dive into every possible nook and cranny just in order to build an application.

I don't think anyone is suggesting that you should.


Yeah... Everytime I try to use something like that and it wants to pull in 10 or 50 dependencies, it's a hard no. I would rather write something from scratch than use something and potentially debug through all those layers.

If it's in my product, I'm responsible for it, so it needs to be possible for me to audit it, even if I may not be looking too closely.


Because Electron developers might say "we fixed it" and the app developer might resubmit based on that and now they're banned due to a mistake made by an upstream dependency.

It's not like this app developer is intentionally using private APIs. "Resubmitting the same thing and hoping that it doesn't get caught" seems to be a strawman.


That resubmit approach ways used by at least one camera app years ago who masked their private API usage to secretly include a volume button “take photo” feature. They were told to knock it off (and Apple also added that option to the API at a later date).

Between that and the folks who hid MAME in an app or whatever, I think Apple is not simply constructing straw men when they warn that attempts to circumvent the spirit of their request - and the letter of it - will result in a lifetime ban.


Camera+ didn't use a hidden API - they just used a standard system volume control but placed it offscreen and monitored if the volume changed (and then lower it imperceptibly if you hit 100%). And Apple has still not added an API to do this officially, last I checked all third party camera apps use a similar hack.

What changed was just the interpretation of the app store rules - the rules said something like "you're not allowed to use hardware buttons in a non-standard way". Once they added the volume shutter feature to the system camera, now it's not a non-standard way and it's not against the rules.


Hence why you should audit your third-party dependencies in cases like these.

How exactly?

I would assume that a quick grep through your project for the symbols mentioned would tell you where the issue is.

it would but it wouldn't solve the problem. This would require the developer to modify electron and basically run his own branch. It would then make your package possibly acceptable (but attention here: as Apple clearly stated keeping too use private APIs can get you banned so if you miss something you can lose your access to the apple store) leaving however everyone else using electron with the same problem. So the solution has to come from Electron.

> So the solution has to come from Electron.

And until it does, developers should not use Electron.

There's a number of reasons why I refuse to use Electon-based apps, and this is one of them.


what if the function calls are generated with macros or something?

Isn't it literally the responsibility of the developer to figure it out, instead of just ignoring it because it's potentially hard?

grep the generated binary.

I suspect that most devs don't do that. I can't imagine finding the time fir that.

Who do you imagine is responsible for making sure your app doesn’t contain malware?

The only answer is that as a developer, you are responsible. Yes, we have to make calculated risks. But the buck stops at you. There is nobody else who can take responsibility for the contents of your app.


you simply notarized the app and you know that there is no malware. Also we are talking about ElectronJS and Chromium -- not exactly untreatable sources. Note that apple does check for malware and quality on the upload stage itself (now done via transporter) so it wouldn't even make it to then review state if something is dodgy.

Apple can’t magically tell that there’s no malware in an app you upload. There is no automated scan which can detect all security vulnerabilities or back doors in code. And we’re talking about electron plus hundreds to thousands of npm modules - which contain who knows what.

If you pull in some bad modules, directly or transitively, and as a result your app steals my data or worse, that’s on you for shipping malicious code to my computer. There is no one else who can be responsible for that. Not Apple. Not the user. You.


I've done that over my entire career. It's always been a requirement. To say you can't find time for it is the same as saying that you can't find time to complete development.

[flagged]


Please don't attack people like this. I'm fairly sure they're here reading the comments, and even if they weren't, you don't need to call them things.

Sometimes saying the truth is unpleasant. But the fact is, these developers have no idea what they are using, or what runs on the users' machines. They bring a ton of dependencies and have no idea what those involve. If that is not incompetency, what is?

"use or conceal"

"use"

If this was "don't conceal or we'll ban you for life", it would be somewhat understandable.

But it's "use or we'll ban you for life" which is just insane. Apple is at the height of their arrogance towards developers.


This policy has been there since the beginning of the App Store.

If you use a private API they will reject the app. If you try and hide the fact you are using private APIs after has told you to stop then they will ban you.

It's all very common sense and not arrogant at all.


> Apple is at the height of their arrogance towards developers.

Yep. I've migrated away from macOS after using it for a decade over to Linux, and the developer experience is first class.


is it possible to write a GUI app that looks native in all common desktop environments yet?

Sure, if you write the GUI portions in the native toolkit and factor out the backend into your cross-platform language of choice.

I would argue that's not really a "first-class" developer experience from the perspective of developing for Apple products on a Mac.

The "first class" experience for developing on a Mac would be to develop only for the Mac. If you're not doing that, your job is going to be a bit more difficult.

Yes, I'm aware. But it's a bit weird to say the developer experience on Linux is first-class. For things that don't have a GUI, sure. But that's not what the discussion was about.

I remember watching the linux communities response to the mono project and realizing it was sort of hopeless.

Qt works well for me, as well as Tcl/Tk.

Qt?

That won't really look native, will it? I thought Qt things looked like Qt things.

As far as my experience goes, it looks pretty native on Windows. Looking at the documentation [0] it also seems to strive for mac-OS native look and feel.

[0] https://doc.qt.io/qt-5/macos-issues.html


This is just a phrasing of a sentence in a mail. It does not define either what reasons they are allowed to ban you for, nor does it define what reasons they will use to ban you.

They are allowed to ban you for literally any reason. What matters is what they do, not the exact phrasing in a random email.

And in practice, they will ban you if you actively try to skirt their rules after they tell you to cut it out.


You assume it isn't an honest mistake. Most people submitting electron apps won't have knowledge of the browser engine layer and its calls to Apple APIs and probably will have some difficulty assessing whether or not they have resolved the issue. That doesn't make them bad people. They are not malicious or trying to hide things. Apple's scripts should give them more chances until they get it right.

Presumably you can't check for violation yourself without submitting.

You can, and the rejection email even provides instructions for how to do so.

And where will you get the current list of all forbidden functions/APIs, not just those for this specific case with Electron?

Whatever symbols are found in the public header files in the /System/Library/Frameworks. Iirc, there are tools which look at a binary's used symbols and compare them to those headers.

Of course you can! How do you think Apple's checking your binaries?

Using some internal tool.

The internal tool is very likely using/parsing otool / ldd output and similar. eg cli tooling that comes with macOS itself

No, it’s almost certainly just a search for strings and looking through the symbol table.

That would be very easy to work around with dlopen and some string obfuscation. It's probably a bit more involved.

In practice it is pretty easy to slip things past the automated checks if you try to, which is one of the reasons they threaten you with a permaban for doing so.

exactly. Apparently Apple just started now to check against these private APIs.

Huh? The problem isn't that the developer itself is trying to cover his misbehavior, but the fact that the developer can get banned for something out of his control.

The developer is the one who takes responsibility for the submission. Enforcement is meaningless if you can just say "oh I asked you to publish dangerous code, but it's not my fault."

It's the same reason people hold companies like Apple and Nike accountable for working conditions in their factories even if they hired a third party to run them. Third parties are not the ones putting their brand on the product.


There's nothing out of the developer's control about what they submit to the app store.

The developer chose to use Electron, hence the entire endeavor is in their control.

> "Keep trying to submit, and we might just ban you forever" is insane.

I was under the impression that if you're being annoying and keep trying to submit a build with private API, making App Store Review's life hard, they're going to ban you. In general, you should be reviewing your dependencies yourself to make sure it's doing things that you approve of; if you can't do that after Apple has warned you that it's doing something that's not allowed I don't really have much sympathy for you.


I think that's being too charitable to Apple. Their review process is automated, and nobody really knows what will trigger the Ban Bot into deleting your account.

There is also no apparent way to scan your own app to make sure that you are not in violation of this issue. So you're in a position where the only way to see if you are in compliance is to submit to Apple, but that may result in your account being banned.


> Their review process is automated, and nobody really knows what will trigger the Ban Bot into deleting your account.

While review is automated, I would like to believe that account deletion isn't.

> There is also no apparent way to scan your own app to make sure that you are not in violation of this issue. So you're in a position where the only way to see if you are in compliance is to submit to Apple, but that may result in your account being banned.

They literally tell you the symbols that you're not supposed to use: it's easy to check if your dependencies are using them.


> While review is automated, I would like to believe that account deletion isn't.

I would like to believe that, too, but I don't.

> They literally tell you the symbols that you're not supposed to use: it's easy to check if your dependencies are using them.

Sure, if you have a better-than-average understanding of C (or Objective C), and know how to use the command line to grep strings out of a binary, and know all of the binaries you need to be searching.

This is a rejection for an Electron app, and I'm going to go out on a limb and say that the majority of Electron developers do not have the requisite skills. Hell, I've been programming for a couple of decades now, and I couldn't 100% guarantee that an app I wrote didn't call one of the forbidden APIs, even indirectly.

The rejection email doesn't bother to say where in the code the problem is, so it's apparently not so easy as to be part of an automated process. "Learn what these esoteric commands do, use them correctly on every upstream dependency your app has, make sure you don't call any of these symbols, and if you fuck up you're banned for life" is utter dogshit customer service.


> I would like to believe that, too, but I don't.

I'll believe it up until the point that "Apple automatically deleted my account because of repeated app submissions" makes the front page of Hacker News. Until then, I have no reason to doubt it as I have never heard of this happening except in clearly malicious cases.

> The rejection email doesn't bother to say where in the code the problem is

I'd argue that any answer to this question would require the skills that you say Electron developers lack. I don't know what your solution to this is, because getting your app past review by claiming ignorance into what your dependencies is doing ("oh no, I totally didn't know this framework was literally malware, can you please let me be on the App Store anyways?") isn't going to work either.


> Apple has no love nor concern for their developers anymore

Because Apple knows it doesn't need to attract developers to iOS. They will come no matter what because that's where the mobile market is.

On macOS it's different. There are very few macOS exclusive developers so most of the popular apps are either cross platform (Office, Photoshop, Sublime Text, Chrome, Firefox, Maya, Cubase, Cinema4D, Resolve, etc) or are from Apple. In both cases the Apple dev experience is irrelevant. There are plenty of boutique devs making small products exclusively for macOS (eg: Panic, Bjango, Bohemian) but these are a drop in the ocean. Apple knows this which is why it's making Catalyst to attract iOS devs to macOS. AFAIK the only big developer making macOS exclusive products is Apple itself.


> Apple has no love nor concern for their developers anymore. It used to be the premier development platform in the world.

Wait a second. When was this exactly? Are you talking about the Apple II era?


There was a time, not that long ago in years, when most of the developers turning up to OSS conferences had Mac laptops of one sort or another.

> It's also completely unsurprising. Apple has no love nor concern for their developers anymore. It used to be the premier development platform in the world. Now it's ... I don't even know anymore.

When has Apple ever been developer friendly?

Their ecosystem always had more money for app developers, but I can't think of any point in time when developers weren't shouting to anyone who will listen about Apple's rules.


Also letting an app use those private APIs can be a security hole.

Ideally anything that is theoretically callable by an application should not pose a security hole. The only issue with private API is that it breaks from release to release.

> I did write back to Apple trying to explain that I am using Electron and I can't really change any of these public-framework usage

Yeah. So? By linking a framework that's using private APIs, this becomes your problem now. And Electron's problem, by extension. Go bug them, not Apple.


How short are memories.

I remember how Microsoft was vilified for supposedly having secret Windows APIs that allowed Microsoft apps to get better performance.

That was mostly made up and even if such APIs existed, any program could have used it.

Even at the height of corporate arrogance Microsoft didn't dream of banning developers for using undocumented APIs.

Apple seems intent on becoming more evil than Microsoft ever was.

At some point the goodwill they built as underdog making great products will run out and some government somewhere will take an anti-trust action.

I'm just hoping it'll happen sooner rather than later.


From what I recall, this practice goes back to the original 68k Apple Mac.

The prehistory is that developers for the Apple ][ had access to third party documentation, and made extensive use of unofficial system variables and entry points. The result was that it became impossible for Apple to update their own system without breaking popular apps and getting blamed for doing so. It turned Apple ][ technology into a dead end.

The Mac was intended to be a much more tightly controlled developer environment. And it came out at a time when there was still a lot of debate over the right way to develop a computing platform.

IBM had a different approach, which was to make things more open like the Apple ][, and they paid the price for it. For instance, a lot of the weird limitations of the IBM PC were caused by developers bit-banging hardware registers and video memory rather than going through "official" BIOS calls that were less efficient.

I don't personally know the right answer, but this is just the history as I recall it. At the time I preferred the IBM approach, because I could do some friendly bit banging and get stuff done, but my programs were mostly for a severely limited audience and lifespan. Today I try to do things in a way that insulates me from knowing anything about the platform that I'm using.


The Mac was intended to be a much more tightly controlled developer environment. And it came out at a time when there was still a lot of debate over the right way to develop a computing platform.

This is very much not true. The entire extension mechanism on Macs was about using undocumented hacks to add functionality. Apple has no control over what a third party app could do through the Classic MacOS era from 1984-1999.

In fact, it wasn’t until around 2011-2012 when Apple started having sandboxing and that was only for Mac App Store apps. It was even later that they had system integrity protection. Even today, you can basically do what you want to on the Mac except for having unsigned kernel extensions.


But Applesoft had perfectly fine extension mechanisms: "&" and "USR()" and "PEEK" and "POKE" and "CALL"! What more do you need?

https://link.springer.com/content/pdf/10.3758/BF03203836.pdf

https://en.wikipedia.org/wiki/Applesoft_BASIC#Extensions

http://nparker.llx.com/a2/as.addons.html

"C is just PEEK and POKE with syntactic sugar." -- Bill Joy


Undocumented APIs get broken. That's a big problem for user experience, particularly if it happens to be being done by a framework relied upon by a very high percentage of app use. Seems pretty fair imo

Is this why so many of the apps on my ipad "need to be updated to work with this version of ios"?

and there is no update.


No, that's because they're 32-bit apps, which iOS no longer supports.

Which is the same thing.

It isn't? There's a difference between dropping 32bit libraries from your OS (after a lot of time in which Apple clearly said "we will drop support!") and banning for using unauthorized APIs inside the MAS.

Microsoft was vilified for many anticompetitive practices.

I worked on an app that competed with a Microsoft app. Our app was actually winning in the marketplace. One year they release a new version of their app with some really cool features at the same time as the latest Windows release. Those features were based on some new APIs released with that version of Windows. Just gave their app a year leap.

Another evil practice was forcing PC makers to pay for a Windows license for each computer sold irrespective of whether the computer shipped with Windows.

Microsoft was pretty evil.


As opposed to "here are some APIs that you can't use but we can, neener neener"?

You are assuming that these Apple APIs are used to give Apple a competitive advantage somehow. From what I can tell, these specific APIs don't. What they do give Apple an advantage in ironically is in forcing more developers to develop using (Apple) native APIs.

The CA prefixed ones are core animation related. Some of the others appear to be drawing frame related. I am not sure what the remote one does. None of these are giving Apple a direct advantage. I bet Electron tried to access to them to draw web pages smoothly.

The Windows API availability window gave Windows apps market advantages.

There are other private Apple APIs that do give Apple an advantage against app developers. Those advantages are in accessing physical hardware and possibly associated software, background processing, and integration (iCloud, etc...) But these aren't the bone of contention.


>None of these are giving Apple a direct advantage.

>I bet Electron tried to access to them to draw web pages smoothly.

How is this not a direct advantage? If these uncommented API calls provide a better performing solution than anything a third party can make then that is a direct advantage. Apps with that call could have a longer battery life or just run smoother.


There is a very valid reason for an API to be kept private, if it's based on internals that are too hardware-specific and you don't want to break compatibility when/if you update the hardware (so a higher-level abstraction is needed and that is in the public API) is a very fair one. Core Animation might fall into that or it might not but it doesn't necessarily is a conspiracy to keep 3rd party apps in the mud.

When you consider that Windows has to keep backwards compatibility with applications from decades ago using whatever calls to Win32, to the point of keeping comments in the source code about why some call is done that way and shouldn't be changed then it's pretty fair that a company providing a platform wants to keep a tidy, secure (or at least following their guidelines for security/privacy concerns) public API.

The Java community had a huge debacle about `sun.misc.Unsafe`, it was a private API being abused by numerous libraries[0] and when its removal was announced there was a quite big backlash about its repercussions.

I don't think that Apple is evil because of its enforcement on private APIs, there might be other issues with this enforcement but there are very valid reasons to do it.

[0] https://blog.dripstat.com/removal-of-sun-misc-unsafe-a-disas...


Public core animation APIs on Apple hardware are plenty fast. I suspect the issue here is that web browsers are acting as yet another abstraction layer and thus are introducing more performance overhead. Electron is probably trying to squeeze as much performance as it can get or electron has a rendering cycle that makes it hard to have it not skip frames due to overhead. Best thing to do is to ask Electron devs.

I was wrong about some of them being drawing frame related. See https://www.cocoawithlove.com/2008/12/drawing-custom-window-.... Apparently customizing the window frame. The CA prefixed ones are correct. Apparently, at least on a Mac, it was more about battery than performance (at least for what Mozilla did) but it was still about the amount of work they were doing per frame (for Mozilla).

Microsoft didn't ban anyone for using undocumented private APIs because they couldn't, not because they chose not to.

Apple, or Microsoft for that matter, would do the same thing here, because the locked down platform is more valuable/profitable then an open platform.

Developed for Android - at least you can have your app sideloaded if the platform owner decided to remote you.

Or better, make your app a progressive web app. Don't use hardware api not available to the browser and you cannot be removed!


> Microsoft didn't ban anyone for using undocumented private APIs because they couldn't, not because they chose not to.

Sure they could have, they had a code signing platform since the mid 90s and could have locked API access only to apps signed by them.

They didn't because it would have been pointless not because they couldn't figure out how.


Code signing does not do what you apparently think it does. They can’t block it unless it’s a windows store app/universal app, which is sandboxed. And that’s exactly what they do for those apps. Tim Sweeney ranted about this quite vocally!

I never said code signing DID do that. Of course it didn't, there were no secret high performance Microsoft only APIs in the first place. I said it COULD have easily been used to do that. E.g. make special API/syscall to unlock restricted APIs, Windows checks the signing status of the executable making the call and only grants permissions if it is signed by MS.

It's actually also not true that Microsoft only ever blocked things based on signing cert from the Windows Store/UWP platform. Windows Defender Smart Screen blocked/blocks apps from running without user intervention unless it was either extremely well known or was signed (and even then if it was new you might still get caught by it).


> E.g. make special API/syscall to unlock restricted APIs, Windows checks the signing status of the executable making the call and only grants permissions if it is signed by MS.

This is how iOS works, FYI.


I think perhaps your memory is short if you think that this is worse than anything Microsoft ever did. Did we forget them funding, to the tune of millions of dollars, a felonious pump and dump scheme designed to defraud investors and destroy competitors with fraudulent lawsuits.

In a completely fair world a substantial number of executives would probably be in jail.


Apple wants to own the user's machine. They want to make it so their computers run only the software they approve. This is already true for iOS and it's only a matter of time before it also becomes true for macOS. It's the opposite of a free system.

Giving up software freedom for "ease of use" seemed like a fine deal at first but then Apple started making decisions that don't quite align with what neither users not developers want. Apple has already started taking advantage of their position as the gatekeeper of the platform.


As a user of macOS, I want developers who makes apps to use public APIs that will be supported so I don't get breakages on system upgrades or migrations.

It doesn't really matter if it's public or not. The fact is people are using those APIs and there's nothing that can be done about that. Nonchalantly breaking stuff and rejecting applications actively subtracts from the value of their platforms and could alienate developers.

Microsoft had private APIs and data structures too and it didn't stop developers from using them. However, their approach to that was different: they maintained bug compatibility with old software in order to keep stuff working. This is one of the main reasons why Windows remained relevant for so long.

The fact is Apple simply doesn't care about backwards compatibility. It's not just private APIs, public ones are also at risk:

https://lists.apple.com/archives/cocoa-dev/2019/Oct/msg00004...

It's not a new attitude either. Apple has always been like this:

https://www.joelonsoftware.com/2004/06/13/how-microsoft-lost...

> A lot of developers and engineers don’t agree with this way of working. If the application did something bad, or relied on some undocumented behavior, they think, it should just break when the OS gets upgraded.

> The developers of the Macintosh OS at Apple have always been in this camp. It’s why so few applications from the early days of the Macintosh still work.

> For example, a lot of developers used to try to make their Macintosh applications run faster by copying pointers out of the jump table and calling them directly instead of using the interrupt feature of the processor like they were supposed to.

> Even though somewhere in Inside Macintosh, Apple’s official Bible of Macintosh programming, there was a tech note saying “you can’t do this,” they did it, and it worked, and their programs ran faster... until the next version of the OS came out and they didn’t run at all.


> The fact is people are using those APIs and there's nothing that can be done about that.

Apple is proving you wrong.


As a user of macOS, why don't you put the onus on Apple to not artificially limit what developers can offer you without it breaking on upgrades and migrations?

Some of the private APIs being used have been stable for generations and are clear improvements in one way or another over the publicly available APIs (like CAContext stuff). I mean a modern OS is not like a library you stick up on NPM and hope no one tries to use internal methods that you'll end up having to support. There are so many desperate teams working on OSX and the applications from Apple that use these APIs, it's not like backwards compatibility, documentation, and most of the issues public APIs face aren't already an issue that has to be tackled.

Apple uses these APIs to make features no one can fairly compete with, which is detrimental to you, as a user, and to external developers. Imagine if any app could use APIs like the ones that Apple Music uses to have tight integration with Siri, or that Apple Maps uses to show on your lockscreen.


> There are so many desperate teams working on OSX and the applications from Apple that use these APIs, it's not like backwards compatibility, documentation, and most of the issues public APIs face aren't already an issue that has to be tackled.

When push comes to shove, Apple can tell those teams to rewrite their code. It can't do that to the authors of, say, Firefox.


What are you talking about?

They literally do it regularly, public APIs get deprecated then removed and consumers have to rewrite their code.

This article is literally about Apple making 3rd parties rewrite their code just to access the app store.

And before you or someone else points out "Firefox is directly distributed", I say: Exactly. So they can use the internal APIs as they please, then Apple can remove then as they please and break Firrfox and... make Firefox rewrite their code.

Apple is not Microsoft. Apple does not work towards not breaking existing software, they actively break it with each macOS and iOS release, sometimes not even releasing the tools needed to fix them before general releases

Making an internal API people are already using public literally does nothing but optionally allow Apple to give a heads up about deprecation. Apple could literally slap "public" on every internal API, break them every release, and the result would be no different than the current status quo because of the overarching rule of App Store admissions... your app has to work, regardless of if an "internal" or "public" API is changed.

Honestly for most developers that wouldn't seem to different from the current situation: see iOS 13 where basic UILabel stuff was breaking.

And again, apps that don't use the App Store already use internal APIs and can already break all the time.


Apple rarely removes public APIs without any deprecation warning that appears when you compile your app at least one version ahead of time.

Apple often straight up breaks the implementations of public APIs leaving developers scrambling to fix them. See modals in iOS 13, or title bar styling.

I work at a development agency and on both macOS and iOS every release is a race to figure out which breaking changes have been sprung by Apple (including crashes caused by silent changes in behavior of existing APIs, people have had apps rejected for breaking on pre-general release OS versions when we didn't even have the tools to test them yet)


There is a difference between breaking a public API which is a defect and that’s done unintentionally - that happens with every operating system and framework - and depending on private methods to behave appropriately.

Decades ago, when Apple introduced 68040 Macs, a lot of programs broke because they were writing self modifying code and that didn’t work with the 68040 cache. Whose fault was that Apple’s or the developers?


It is not a defect. It is literally intentionally broken! Do you actually know this space?

The modal example, it's to support new design language Apple is pushing, straight up breaks modals designed a certain (valid) way.

Catalina removed XML exports used by music apps. There was no deprecation warning.

Apple's recommended fix? Don't update if you need one of those apps.

These are not defects, they are literally breaking changes intentionally made with no warning.

I don't understand why all of you seem to be operating underthe assumption apps using "public APIs" just work with each OS update. It just doesn't work like that. They break and crash not due to defects but due to intentional changes


It was part of the first beta release that the new iTunes wouldn't support XML exports. So there was warning that it wouldn't work. Public API's doesn't mean "something will never change". It should mean that API's won't change between minor version numbers. The entire purpose of semantic versioning is that there might be major breaking changing when there is a major release.

Apple did in fact provide a method to share music between apps and some apps do take advantage of it. Do you really think that Apple didn't need to do a major overhaul of iTunes?

Of course it's Apple's advice and common sense not to upgrade your OS until the apps you use are updated to support it.

This is all modern software engineering 101.

As a developer there are a few expectations.

- depending on private method may break your code with any point release. The vendor has no obligation not to break code if you depended on a private API.

- If your code breaks calling a public method during a point release, it is a bug and the vendor has an obligation not to break public API's when releasing a point release.

- If the vendor makes a breaking change during a major release (x.0.0). It's the vendor's responsible to communicate the breaking change and give enough notice to developers/users about breaking changes so that either the developer can fix their code, the user can find a replacement app, and/or the user not upgrade.


You spent so many words to latch onto a single part of my entire comment, construct a strawman around it, and burn it down.

But lo and behold something useful did come of it, I finally found the fundamental misunderstanding keeping you from understanding what the crux of the issue is.

> If your code breaks calling a public method during a point release, it is a bug and the vendor has an obligation not to break public API's when releasing a point release.

Not when the vendor is Apple.

This whole time you've been operating on the set of rules that apply when your vendor considers you a partner of sorts, maybe in the vaguest sense of the word, but a partner nonetheless.

iOS point releases break things literally all the time. Iirc we actually saw more fires on 13.1 than 13.0

This literally has nothing to do with semantic versioning or whatever else you want to confuse it with. It's a blatant disregard for developers that Apple has carried throughout it's operations, from APIs to app store rejections. If anything the only reason they get the slightest pass is they're not Google, who manages to make talking to a human, no matter how hard they stonewall you, a selling point in mobile developer relations now.


No one is going to argue that this entire release cycle hasn’t been a clusterfuck and the rapid release cycle of iOS/MacOS/watchOS this year is evidence of that.

But your argument has nothing to do with this submission - using private APIs.

At least one of your two examples - getting rid of XML exports - wasn’t about Apple breaking a public API during a point release. How is it a straw man refuting one of your major points? It was about Apple changing an API during a major release and letting developers know. This is how a vendor should behave.

Now whether they gave developers enough of a warning is a completely separate argument.

BTW: While it is a major change and no longer automatic. There is a manual workaround...

https://djtechtools.com/2019/10/10/update-to-catalina-heres-...


My point with that example was about how Apple doesn't treat developers as partners, something I said multiple times in my other comments is the crux of the issue, which this whole internal API in Electron rejection issue is simply a symptom of.

You ignored my perfectly good example of Apple breaking an API because you have nothing to say about it.

You ignored my comment you just replied to pointing out how irrelevant sem-ver is when your "vendor" doesn't care about you.

You are fixated on trying to nitpick the one tiny foothold you've found for your screed, one which only exists because you're ignoring the initial point I, not the article brought up, that this is an issue with Apple not caring about developers literally in the first comment you replied to.

Maybe spend more time reading and less time replying.


You gave two examples - the one I know about “broke” with a major version release, was known during the beta period and is exactly how a platform vendor should behave. The only thing in question was the beta period long enough. The other you didn’t say whether it was a point release or an iOS 13 change.

The electron rejection is not a symptom of Apple breaking a public API. It’s just the opposite. An API change didn’t break Electron apps - it was rejected for using a private API.

It’s not “nitpicking” to point out that your examples are completely irrelevant to the submitted article - Apple rejected an app that used private APIs. None of your examples have anything to do with the submitted post.

Would you also complain if you wrote a C program that depended on documented “undefined behavior”...

  int b= a++ + ++a;
and it broke with the next version of the compiler or broke based on which optimizations were turned on? Yes I am sticking with examples of how irresponsible it is to depend on private APIs and undocumented behavior - something you advocated in other comments because that’s the entire point of the submitted article.

Again you spend more time replying than reading.

I said this internal API rejection situation of Apple not treating developers like partners

Like it's literally right there in the comment you replied to clear as day and yet you manage to muck it up then spend several more paragraphs on a new screed nitpicking your wrongly quoted text.

I'm done replying to this.


The internal API rejection is about not treating developers like “partners”. You aren’t their partner. Internal APIs are just that - for internal employees.

It’s dumb to use “internal”, private APIs. It always has been. It hurts your products stability, it hurts your customers, and it keeps the platform vendor from making rapid changes.

Microsoft never cared about you as a developer - they would just as easily run over you if it met their business objectives.


Ugh, I promised myself I'd stop replying, but I'll ignore most of this comment and correct some obvious misinformation for the benefit of other people who actually read comments.

Microsoft has a history from the earliest days of existence of bending over for developers.

Going as far as to literally to add a special case to their memory allocator to support explicit undefined behavior (reading memory after free) for when a specific game, Sim City.

They avoided writing more than 80 characters on any given line in system.ini, because one specific program would fail to read those lines correctly, then delete the system.ini when attempting to write it back

Microsoft is literally still packaging 16-bit subsystems with Windows 10

Anyone actually interested in learning more about it should read Raymond Chen's blog and learn about the truly insane lengths Microsoft goes to make sure they don't break what developers have done, no matter how wrong it is:

https://devblogs.microsoft.com/oldnewthing/author/oldnewthin...

Honestly anyone who doesn't know the lengths Microsoft goes to treat developers as partners doesn't have the base knowledge for the conversation this thread has been about, but I digress.


Just like `sun.misc.Unsafe` was around for ages until it wasn't. [0]

[0] https://blog.dripstat.com/removal-of-sun-misc-unsafe-a-disas...


I fail to see how this is anything but the perfect case for allowing internal API usage.

There was no other way to do what Unsafe did, so people used it for years.

A lot of people used it to do useful things in Java. So much stuff that this article is saying it literally became indispensable for much of what Java is used for. The ecosystem was better for it.

Sun says we want to remove it.

So Sun can provide alternatives that do the same job, or find that it generates so much value that it shouldn't be removed, or remove it and leave people literally exactly where they'd be if it never existed if there's no other way to do what it does. People would gnash their teeth, but the message sent is "Java was never the right tool for the job so we don't want you as a user."

And the article rightly points out, Sun was removing it for the sake of removing it. Having a bad engineering structure where that handwavy rant about Unsafe can justify removing a useful feature has nothing to do with internal vs public APIs.


The usage of Unsafe was never encouraged, it is a problem that Sun never provided a public API with similar features but relying on a private API is what caused the issue of breaking changes in the future, something that every Java developer was well aware that could happen.

Yes, I agree that the problem was that Sun didn't provide a public API for it, at the same time developers breaking the contract (instead of pushing for it to be moved to a `java.` namespace) shouldn't be excused and embraced, it causes bigger issues to the overall design of the platform when then you have to be maintaining an API for the sake of usage, the same cruft that Win32 suffers for its whole existence, and which made developing on Win32 a pain in the ass for a lot of people, for the sake of not breaking some twisted way that a major application used it.


> so I don't get breakages on system upgrades or migrations

This is hilarious, Apple breaks apps that only use public APIs on virtually every release they do, minor releases, security patches, you name it. Apple CONSTANTLY BREAKS THINGS.


There's no need to shout; breakage in public APIs is nothing compared to private API churn. Plus you can file bugs about the former.

It's very weird for me to see people acting like Apple is "becoming" anything. They've been pretty consistent about their spot on the user freedom/paternalism spectrum, for at least a decade. This is in line with the choices they've been making since at least the launch of the iPod. Ease of use has never been exclusive of user freedom, and Apple's desire to control users has never been about the user: any half-decent interface is capable of hiding power behind an easy to use facade.

Two stereotypes, each about a decade old. The rumors about the impending doom of freedom on MacOS is as old as Mac OS X. At this point, it's the slowest conspiracy in history.

People don't prefer MacOS because they are idiots who need "ease of use". There just is no other system developed with something approaching taste. Windows is for those people that put plastic covers over their furniture, ruining in the process of trying to protect it. Linux is for servers.


Apple is the company that already has a completely locked down mobile OS and is actively nurturing an app store for the macOS. I wouldn't bet on it running unsigned code forever.

Apple has explicitly stated in WWDC sessions that there will always be a way to run unsigned code if you want.

There are no such things as “secret APIs”. By definition an Application Programmers Interface is the vendors promise to other developers that when you call it, it will have well defined results no matter if the implementation changes. Every modern programming environment has the concept of public and private methods either enforced by the language (with hacks to get around it) or by convention (prepending a function with an underscore)

The fact is that all of MS’s Office competitors early on wrote horrible GUI apps whether it be fir Windows or the Mac.


> There are no such things as “secret APIs”.

I don't know what Apple means by "secret APIs", but I'm assuming they mean "undocumented APIs". Those are certainly real things that commonly exist.

> By definition an Application Programmers Interface is the vendors promise to other developers that when you call it

Yes, but those "other developers" may be other engineers in the same company. The APIs they use are still APIs, but are not intended for use by anyone outside the company.


That’s true. Apple doesn’t say “secret APIs” that’s a conspiratorial phrase made up by third party developers.

Say Team A within Apple creates a module that is only to be used by Team B and C. Then Teams D creates a module that depends on Team A and B and they release a public API.

Team A should publish an internal documentation and Teams B and C should also not use methods that were not documented by Team A and Team A shouldn’t follow standard semantic versioning. If Teams B and C need some functionality they should inform Team A.

The same goes for Teams B and C. Also, Apple controls the release schedule for any internal teams. If they want to move to ARM tomorrow they can coordinate it within Apple without breaking any third party apps. The only team that has any responsibility to not break external developers is Team D.

If Apple starts allowing external developers to use private functions now their release schedule is tied to when enough major third party developers update their documentation.

Amazon is even a better example. They have a policy that everything should be a service internally and no team should reach “inside” of the implementation of another team.


I believe CAContext is private API but performs better than documented alternatives.

I trust the EU with these matters, more so than any other government.

So you expect the EU to not allow Apple to ban the use of private methods? Are they going to also ban Apple from not changing them?

What happens when Apple updates the operating system and starts throwing up a big dialog box every time an app accessed a private API that says “the publisher of this app needs to update their poorly written app.”?

What next? Is the EU going to also ban language makers from having public and private functions?


Exactly. An application developer chooses his dependencies and has to take responsibility for them. Even if the app store is going to let you pass the buck, it's going to make your customers unhappy.

How is it going to make customers unhappy if your app isn't using the features?

Apple is within their rights here, but please, let's not pretend this is about user experience.

It's about the Apple machine doing what it wants, and rolling over who it wants, because it can.

That would explain why Apple developer relations (read: humans) had previously backpedalled after the same rejection in the past:

https://github.com/electron/electron/issues/20027

Most likely these rejections were not intentionally resumed, but because the machine that is app stores these days is completely non-deterministic, this could still be a big problem.

This time the wrong developer could reach out to the wrong channel and trip some sort of trap that turns this into a "known issue: won't fix + always send automated reply", instead of someone with the right connections getting to the right person and having them go and flip a switch that fixes everything with their pinky finger.


It’s more of a general point that if your application is buggy, the customer isn’t going to give a damn whether the bug is in your code or in somebody else’s code.

And? That's exactly why internal APIs should be allowed.

The problem isn't the usage of an internal API, the problem is the breaking of an internal API.

Which is already covered by App Store testing and guidelines which already require your app isn't a broken mess.


this is exactly what they told me in the follow up message. I am somehow surprised how the bug in electron repository is not given much importance at all.

> I am somehow surprised how the bug in electron repository is not given much importance at all.

By Apple, or the Electron developers?


after this post apparently the issue has been upgraded to a bug and someone is working on it. I hope they will find a solution OR at least let everyone know that they shouldn't bother creating MAS packages and upload the apple store. I think it is dangerous as it can get you banned.

This summarizes Apple's attitude to developers. Eventually, you'll run foul of some obscure nonsensical Apple policy, and Apple will not hesitate to show you the finger. And Shame you for your dev choices.

Calling private API is not nonsensical Apple policy, and you're reducing the instances in which rejection is nonsensical Apple policy.

The post shot to #1 on HN in no time, because the developer community thinks this rejection, and it's backing policy to be nonsensical.

The post shot to #1 because there are a lot of Javascript developers that see Electron as a gateway into apps they would otherwise be unable to develop. There's a lot of interest in whether or not that door closes.

Apple's policy towards private APIs has been known for years.


In which universe is it good for Apple to roadblock JavaScript (or any other language) developers?

You misinterpreted my comment.

Apple is roadblocking the use of private APIs, not languages. Or interpreted another way, they're roadblocking frameworks, not languages. This is true whether you're using Javascript, Swift, or C. This rule has been in place for years.


> because the developer community

Which is not a homogenous group, both in ideals and for why they'd upvote a submission like this.

> this rejection, and it's backing policy to be nonsensical

They're different things. I personally think the rejection is perfectly sensical in the context of the backing policy, with which I don't fully agree.


You must be chugging the koolaid to believe developers LOVE Apple's policies, or enjoy getting their hard-work rejected by a bot, or getting shamed by an overzealous Apple employee on HN. Developers are homogeneously unappreciative of Apple's treatment of them. They just don't have any leverage, or opportunity to negotiate

…you're replying to a comment where I state that I don't fully agree with Apple's policies.

Who are you going to blame when applications start breaking because Apple removes or changes the functionality of a private function? [1] without warning?

When you are writing any software that has a public API you should feel no obligation to change the functionality or completely remove a private method without warning.

[1] I refuse to call it a private API. An API is public documentation of the inputs and expected behavior of a dependency. It should be a completely black box how that functionality is implemented.


Blame the developer? Which is why, when an app breaks on the Mac store or app store, users pound the app with 1-star reviews. Even if the breakage happened from a platform (iOS or MacOs or Android) bug.

This is not Apple "watching out" for the developers, no matter how much you spin it


If enough applications break, users are more than likely to blame the "stupid Apple update" rather than their apps.

It's Apple watching out for users.

Doesn't help that developers still buy their machines.

Apple will only listen if it hits their bottom line.


The problem is that flakey software on their platform, that breaks on OS updates and bug fixes annoys users, and thus also hits Apple's bottom line.

The rejection is legitimate, but it's still a big issue for developers of Electron apps. The fix should happen in Electron if at all possible.

Yep.

If you can't avoid Apple's stores then make damn sure you fall in line as they effectively own you.


You can choose to distribute outside of the Mac App Store on macOS.

What about on iOS? And what about the fact that on MacOs notarization is more expensive than publishing to the store? I don't believe that to be a coincidence

Notarization is free.

Creating a Developer ID certificate requires a paid Apple account. Hardly free.

I think only a distribution certificate requires a paid account.

Now you've thrown me a curveball. I will have to test. I think last time I looked, Developer ID is considered a distribution certificate and requires payment.

I'll admit I haven't tried this personally, either; I've just heard that it's possible.

Apple just rebuilds any popular app and makes it first party anyhow. At some point most developers will stop bothering just for that.

Really? Can you link their Sketch and Photoshop replacements? I know some designers who could use those.

Apple doesn't rebuild apps that require massive features, but they do often build things into the OS or as base apps that negates the need for apps, some of them wildly popular.

Apparently Apple silently whitelisted Electron for some time.

Wouldn't a more reasonable path be for Apple to talk directly to Electron and Chromium about the issue and work out a path forward before rattling a banhammer at app developers, though?

I mean, did Electron or Google just refuse to fix this? Are these private APIs things that actually get exercised in the apps being threatened?

It's not so much about culpability or Apple's right to control their app deployment environment, it's that the response seems really disproportionate to the offense and pretty badly misdirected.

A more conspiratorially minded poster might wonder if the real goal here was to dissuade developers from using cross-platform frameworks...


Why? It’s very clear what’s wrong. Don’t use private APIs.

Thank you Apple for keeping things clean!!


Chrome and Firefox are using a critical feature that has no equivalent public API. If they didn't then they would end up using 3x as much energy which is important for the battery life of laptops and phones.

No. Apple is responsible for their platform, not the ecosystem.

Putting it together:

This is about submitting an app to the Mac App Store. Apple has had a requirement that apps not use private APIs for a while.

It sounds like Chromium, and hence Electron have had references to some private APIs for a while, but Apple has only recently started enforcing their requirement. (Or perhaps only recently started scanning for these particular APIs.)

It’s a little painful for the developers for this to suddenly pop up like this, but it’s better than all Electron apps suddenly crashing one day, which would have happened sooner or later when one of these APIs changed or was dropped.

The solution is a Chromium fix to avoid using these APIs, and an associated Electron release to incorporate the new version of Chromium.


Judging by the history of a related issue on the Electron Github project [1], I suspect that Apple might have given the framework a two-month grace period starting in early September, and that just expired. Or the exception was supposed to be permanent, but something made it stop working.

[1]: https://github.com/electron/electron/issues/20027


> It sounds like Chromium, and hence Electron have had references to some private APIs for a while

I wonder if it has been that way in Chromium since Blink was WebKit and maintained largely by Apple with priority on performance on Apple platforms.


Apple's WebKit is safe to compile for their stores. The scripts and macros WebKit has disables use of private API unless you are compiling against Apple's internal SDKs.

Edit: Sorry, no. Only JavaScriptCore is safe for stores, not the entire WebKit project.


You are missing that Chromium uses these APIs in the first place because they offer better performance or necessary flexibility. Since Google doesn't distribute Chrome on the Mac App store, chances are they don't care about "fixing" Chromium to not use them.

So, feel free to use Electron, just understand that your so easy to develop desktop app now hinges on the ability of a few unpaid developers (that's probably not you, or the "full-stack" people at Slack) to continuously keep track with the Chromium source and maintain their no doubt massive patches to its code to remove use of these private APIs.


> This is about submitting an app to the Mac App Store.

Indeed, and the article's title is confusingly wrong, as "Apple Store" refers to Apple's retail and online store that sells hardware.


This should get interesting when apps like Slack / Spotify need to ship their next update, I wonder how they will workaround this issue

it seems that the scanning started these days. I had an app build a week ago and I didn't have any API error in the rejection.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: