Almost done with AppCode... or, "Why the hell is this thing so slow!?"

Answered

I have used AppCode for the past 18 months or so, and think the “vision” for what AppCode could be is superb. The execution, however, has become increasingly abysmal (to me, at least, and for my use cases). I pop open AppCode wanting to do some work, and then wait up to 5 minutes while AppCode launches, indexes, updates symbols, seems to index some more, builds module maps, etc.

After all of the waiting, “indexing” and “pre-processing” I expect AppCode to resolve symbols almost instantly. I mean, it's spent the past 5 minutes build indexes (on an iMac with 32GB RAM and 6 cores). How can it not have built enough indexes to do everything really quickly. But, alas. Symbol resolution has been become increasingly slow as the past 18 months have gone by. 

Then, to add insult to injury, after the slightest tickle / code change, AppCode starts rebuilding indexes, module maps, etc. etc., ad nauseam.

In total frustration, a few days ago I decided to switch back to Xcode 11.1 as my primary Swift IDE. What a breath of fresh air... everything feels *light* and snappy. Xcode starts up rapidly (no more than 5 seconds to load my projects), and is usable right away. Yes, Xcode’s “inspections” aren't as “deep” as AppCode’s, and the lack of semantic highlighting in Xcode is a (somewhat bitter) loss. But at least I can get code written.

Out of total desperation I tried the latest 2019.3 EAP builds. Both the latest build, and the one before latest, are sl ll ooo oo ooo wwww w. So slow, in fact, that it feels as if I’m typing into a remote SSH session over a very slow 9600bps connection. Completely unusable.

I don't know what Jetbrains’ plans for AppCode are, but you guys *seriously* need to do something about the performance problems. I am trying to decide whether to cancel my subscription tonight or try “one more day”.

I’m not really looking for any suggestions at this point—I’ve tried everything from switching to the latest Java runtimes (via the Choose Runtime plugin), disabled every single plugin inside AppCode (including Git) in an attempt to “lighten the load”. I've tried RAM disks for AppCode's cache / derived data. Tried tweaking JVM settings, allocating more RAM to the JVM, running AppCode off an external (2GBps SSD), etc. All to no avail.

Something is seriously broken / wrong with the current state of affairs, and the trajectory that AppCode’s performance has followed.

If anyone from Jetbrains is listening, please pay attention... there are similar complaints about other Jetbrains products (IntelliJ, PyCharm, etc.) all over the web. This is not an isolated issue, and it is seriously tarnishing Jetbrains’ reputation. At one time I though of Jetbrains as innovators, and my "go-to" tool provider. No more.

If someone has a magic rabbit / silver bullet, I’m willing to give it one last try, but I have my doubts. My time is too precious to spend debugging AppCode, disabling every plugin under the sun, having my rhythm interrupted by “Indexing…”, etc.

8 comments
Comment actions Permalink
Official comment

Stuart, I'm very sorry to hear that. Performance improvements are main target of our 2019.3 release and we plan to continue working in this direction further. TBH, we already received a few reports from our long-term users that performance of latest 2019.3 EAPs improved a lot. If that's not the case for you, we would appreciate if you share logs+thread dumps (Help | Show Log in Finder) and capture CPU snapshot during symbol resolution phase and while typing (when you see the slowness) and send it over our support channel or via YouTrack issue.

It might be something specific in your project / workspace, so disabling plugins, switching JRE, etc, wouldn't change the situation. We'll be glad to help if we figure out the cause of the problem.

Comment actions Permalink

Don't get your hopes up.  Even with the "new" EAP that was just released a few days ago it's still a joke.  In fact it might be more of a joke now that it was in the previous version.

Here's how it goes now:

  • Start AppCode
  • Processing Swift Modules... (2 minutes)
  • Loading Symbols...
  • Updating Module Maps...
  • Updating Symbols...
  • Processing Swift Modules... (3 minutes)
  • Loading Symbols...
  • Building Module Maps...
  • Updating Symbols...
  • Processing Swift Modules... (2 minutes)
  • Start using AppCode
  • Make pretty much any change
  • Processing Swift Modules... (2 minutes)
  • Loading Symbols...
  • Updating Module Maps...
  • Updating Symbols...
  • Processing Swift Modules... (3 minutes)
  • Loading Symbols...
  • Building Module Maps...
  • Updating Symbols...
  • Processing Swift Modules... (2 minutes)
  • AppCode usable again
  • Rinse and repeat above

All of that on the new Mac mini 2018 with 6-Core i7.

How JetBrains has manage to go from good tools to some of the junk they produce now is beyond me.  They use to be my favorite tools, but now everything is going down hill.  They are taking away options from the coder and forcing them into their way of doing things across a number of their tools along with the performance taking a nose dive.

Obviously they've bitten off more than they can chew will all their tools and the quality and performance that use to be a hallmark of their tools has now turned into terrible quality and performance. I'll probably be forced to look for another set of tools soon if they continue on their current path.

Here's hoping they fix whatever problems they've created internally and get back to actually be quality products.

1
Comment actions Permalink

Steven,

That's not the behavior we would expect from the latest 2019.3 EAP. Would you be able to submit an issue in our tracker and attach logs (Help | Show Log in Finder)? Which Xcode version do you have selected in Preferences | Tools | Xcode? It would be also helpful if you capture a screencast of this repeating Processing Swift Modules phase, especially when you're not invoking actions in IDE. This is really strange.

When you mention

>in the previous version.

do you mean previous 2019.3 EAP didn't have such problem in your case, or you refer to 2019.2.x release version?

0
Comment actions Permalink

Hi Steven,

Your experience exactly parallels my own, and is the reason why I have simply given up on JetBrains.

In order to preserve my sanity (and preserve the joy of coding, which AppCode completely destroys—repeatedly hanging, and/or deciding to rebuild symbols etc. breaks my flow and interrupts deep work) I have uninstalled all JetBrains IDEs from my machines. This way I don’t live in a state of perpetual “hope disappointed” and don’t end up spending hours trying to tweak AppCode and get it usable. 

I suspect the issues are deep enough that JetBrains isn’t going to fix them over the course of a few EAPs. Perhaps I’ll try again over Christmas 2020. Until then I can save both money and my sanity by sticking to Xcode and VSCode (which, btw, I’m increasingly pleased with—took a bit of learning but is paying dividends already). 

1
Comment actions Permalink

Hello Tatiana,

I'll do my best to get you some logs, but currently I'm under some pretty heavy deadlines and AppCode is removing time from me, not giving me time back.  Just some quick info since I'm already writing this message.

I experienced the issues with AppCode 2019.3 EAP 193.5233.22 which is the latest I'm showing in your Toolbox as of this post.  I reverted back to 2019.3 EAP 193.4932.6 which is the previous edition available in the Toolbox and the performance is much better than 193.5233.22 but still has quite a few issues.

I'm currently targeting Xcode 11.2 (11B44) which I believe is a beta.  I'll be trying the GM 11.2.1 tomorrow and I can see if that helps.

While I understand the challenges of working with Apple in any regard and I'm obviously a developer myself, I'm seeing a concerning pattern from JetBrains of half way done implementations and a loss of focus on what's important.  I know you have a large list of things you'd like to put in your tools, but the core functionality of your tools has become suspect.  It doesn't matter how many bells and whistles you put in your products, if the core functionality and performance doesn't work flawlessly, those other things are worthless.  I know the EAPs are beta/testing editions, but a lot of times we developers are forced to use them because there are large gaps in your release products that support up to date APIs/platforms/etc.  When Apple forces me to support specific things and only your EAPs support them, I'm stuck using beta/testing versions.  I know that's not your fault, but it is your responsibility to understand that's how it works and figure out a way to provide what's needed.  I can't stop using AppCode for a month or two when Apple comes out with something new just because the stable version of your app doesn't support it while you work on the EAPs.

I'm not sure if you are part of the AppCode team or part of a larger support team, but I currently use no less than 5 of the JetBrains tools/languages and I'm seeing the same thing across all of them.  A total loss of focus on the core functionality, performance and configuration.  I will probably be going the same way as Stuartro and find another company to support if JetBrains is going to head down the slippery slope of ignoring what made their tools great.  I've been a big fan of everything you have done up until the past year when everything has taken a very steep decline in quality, performance and configuration.

Here's to hoping JetBrains returns to what made their tools so great.

1
Comment actions Permalink

Hello Stuartro,

I totally understand saving your sanity and I'm glad you've made a successful transition off of AppCode for the time being.  I wish I was able to have that option at the moment.  As you may have read in my message to Tatiana, I use no less than 5 tools/languages from JetBrains and the transition away is going to take some work.  I hope they surprise me and I don't have to deal with the move away.

The following is my experience with those tools and me hopping up on my soapbox, so you're welcome to stop reading here. Tatiana may be interested in this list.

The tools have gone like this:

  • AppCode: Lag of keeping up with Apple's changes with stable releases which forces use of EAPs in production and significant degradation of performance to the point of uselessness
  • IntelliJ IDEA Ultimate + Kotlin:  Loss of configuration for code style and degradation of performance
  • Android Studio (based on IntelliJ) + Kotlin: Loss of configuration for code style and degradation of performance
  • PhpStorm: Loss of configuration for code style on new forced features that are half implemented and shouldn't be arrogantly forced on the users.  Loss of consistency with auto-complete, code checking/validation, false errors and invalid linting
  • DataDrip: Significant loss of performance with some options selected
  • CLion: My least used so I haven't been impacted by changes there, but hopefully they haven't gone like the others
  • Kotlin Language:  Force code style formatting that doesn't match my preferred code style and a significant reduction is configuration verse Java and all other languages around all their tools.  This rubs me wrong in a major way because I chose JetBrains tool years ago because of the freedom they gave me.  Just a note for JetBrains as a whole... YOU  DO NOT KNOW BETTER THAN ME ABOUT HOW I SHOULD CODE.  Going the way of many others that force stupid ideas on others is not productive and innovative.  If you are concerned about the up and coming generation of programmer, TEACH THEM.  Don't make tools that cater to the stupid. As the saying goes, if you make something that an idiot can use, only an idiot will use it.  Educational tools and help in the app and on the web is WAY BETTER than dumbing down a language is hopes that uneducated people can use it.  It's programming... it requires the use of your brain by its very definition.

While there is a bunch of stuff I like about Kotlin, there are some things that are really stupid and are just changes for the sake of change.  Removing useful things that a ton of developer use in current languages like you know better than the millions of developers on who's shoulders you are standing is just arrogant.

I'll hop off my soapbox now, but it's sad to watch the tools you have loved to use for years get to the point where you may have to look elsewhere.  I'm passionate about programming and the tools that drive great productivity and JetBrains was the king of that hill for a while.  I just hope they get back there before it's too late.

1
Comment actions Permalink

I have the same problems with AppCode and I am switching to Xcode+VSCode too.

0
Comment actions Permalink

I used to use AppCode a few years ago and loved it. Then somewhere down the line Swift happened.  Had to abandon it due to the poor performance with swift (Indexing of swift modules & build took forever).  I moved back to Xcode. Now I  have grown tired of XCode.  XCode simply misses the mark for most  pro developer features that I would expect in a simple IDE. So I decided to give AppCode  another go with the latest 2019.3 version. It looked promising. So here is my feedback.

It spends an incredible amount of time indexing swift modules. The random pauses are annoying. What I don't  understand is the need to re-index all the iOS frameworks. What is the need to regenerate module maps for foundation and other OOTB frameworks every time a project is swapped? Why cant these be cached or run once only or optimized for speed?   Apple has made it easy for companies like Jetbrains to compete by abandoning storyboards and xibs.  Apple iOS/macOS developers looking for a better alternative to Xcode. IMO Appcode is close but does not cut it. 

0

Please sign in to leave a comment.