Problems with Android Studio
techcrunch.com
techcrunch.com
1 - The author is right: The WYSIWYG GUI tools are buggy as hell and I have just have the kids dive into the XML - which brings its own set up problems.
2 - The gradle system is hard to configure but once it is right and you check in the configs you don't need to change it.
3 - It basically requires 8GB to run with any reasonable performance. Getting a set of laptops with 8GB for a non-profit is a challenge! Even with 8GB, build and deploy cycle can take 3 - 5 minutes.
4 - I do like the remote debugging. It is essential for debugging a robot with a phone that is driving around on the floor.
Android 2.0 was an improvement, but it is still a challenging environment.
I am a competent programmer who uses IntelliJ at work, so I don't know how other FTC coaches could possibly get a team up and running with Android Studio.
http://www.firstinspires.org/robotics/ftc
If so, what a seriously amazing group....if not, I'll update the link!
Getting students up and running with Android Studio seems similar to trying to teach HTML+CSS+JS, by having students start with Grunt/Gulp + WebPack/NPM + Ember + Bootstrap and more.
We don't usually do that, because it's a crazy amount of complexity for someone just starting out. Most students begin with something like "edit a single HTML file to learn basic HTML+CSS+JS", and get gracefully introduced to the rest as they learn.
I imagine we need an equivalent of that for Android. I don't know what specifically that would be, but it's probably not Android Studio.
PS FRC was my life for 2005-2009... great memories, an incredible program. Definitely instrumental in getting me to where I am today. :)
Couldn't agree with you more.
Point 4 - Remote Debugging is an especially important one. Not only not having to connect using the cable but saving the tremendous amount of wear and tear on the phone USB connector. This is usually a big factor in robot failure due to loose connections during a competition. Thank God for inventing Duct Tape.
If I didn't personally use Android Studio before it would have been a huge hurdle to teach my team to use it. Too many moving parts, the android ecosystem and the wide variety of SDKs and tooling. What would be considered as a great selling point otherwise is a burden to get setup for a bunch of middle and high schoolers.
Yes, the Visual Layout editor is wildly inaccurate, and yes, the emulator sucks. There's definitely room for improvement.
But if you look past those two issues, the rest of it is pretty nice. I certainly wouldn't call Android Studio or IntelliJ a "gruesome embarrassment". (Is the author aware people willingly pay money for IntellIJ? Even for non-Android, non-Java work? That there's an entire company around IntelliJ and various versions for various languages.)
What I see in this rant is another spoiled new-school dev who wants everything handed to him on a silver platter. That's not to say Android Studio could use improvement; more that this guy seems to lack the mental tools needed to reason about complex software
I don't see any devs, old or new, using HTML table tags to build grid systems just because "Hey, I'm so smart that I have the mental tools needed to reason about complex TR, TH and TD tags". It's 2017, if the author is asking for a more competent dev environment then he has the right to his opinion.
I'm not totally against it, but his point stands. Even C# and .NET with WPF has XAML data to modify directly, but it's much more robust. iOS puts a spiffy dev GUI in front of everything and tailored in a way that doesn't really restrict, but still allows the option to dig into the raw side of things. However, it's still very necessary to reference the raw data on AS, so much so that there's a UI for the raw data.
Yer damn right I am! Kids these days!
Overall I love it. Compared with Xcode and the work I was doing before on iOS Android Studio is a dream.
It certainly runs far better than Xcode, since that won't even start on any of those!
That's exactly what I do. Didn't try it on the same time, though.
What I had problem with in the past, was running Hyper-V and HAXM. Both require their own hypervisor, both need a reboot to activate it and they cannot be active at the same time.
Xcode is not the greatest development environment, but the iOS simulator/debugging actually works.
Android development is painful unless you have an physical device to develop with.
Does anybody develop a serious Android application without testing it on an actual device?
The IDE talks to the emulator via ADB. It does not have to talk just to the emulator, though. You can replace it with a physical device, the IDE doesn't care.
When you replace the emulator with a physical device, it gets much better.
Edit, here's a good source for an image. http://www.osboxes.org/android-x86/
It is all relative, I guess. I started writing Android apps when the Android SDK on Eclipse was the official solution and compared to THAT Android Studio is an incredible improvement...
It does have its warts, for sure. I don't even bother trying to use the GUI layout designers and just stick to hand-writing the XML. I don't use the emulators, I stick to testing and debugging on-device. (I have had the emulators in states where they worked just fine, but the requirements for lower-level HAXM support to get them running at an acceptable speed do cause a lot of problems in the real world).
I don't understand why it ships with "Instant Run" enabled by default since in my experience that feature still cannot be trusted in any but the most featureless demo apps. That feature should still be treated as very experimental and disabled by default so as not to cause serious confusion among people who don't understand the implications of using it.
All-in-all my list of complaints is pretty small, though... smaller than the list I've had for any IDE I've used regularly since Visual Studio 6.0.
The New Visual Editor is pretty good, as well as the new emulator. The layout editor has been rewritten from scratch and it really shows.
There is definitely room for improvement, but "gruesome embarrassment" is ridiculous.
Especially with all my cross platform colleagues hoping that they could use Intellij instead of xcode on iOS.
NDK programming still sucks, although it's been slowly getting better. Android's activity/fragment lifecycle/state restart is a bugfuck. There are legitimate grievances to be had here, but this guy isn't hip enough to the system to make them.
I do a lot of custom UI work and then you really don't have much choice other than to run your app every time you make some small adjustment. And no amount of fast CPU, Genymotion, or super fast devices has made this fast enough. Web devs don't know how good they have it.
I've found this to be one of the brightest spots of working with React Native. Having most of the application code in Javascript and good debugging tools really reduces that cycle. I use an app called Frappe and it's just shift-cmd-r to reload the app's javascript.
There are still some parts of the app we're using native code for, and it doesn't help there.
That said, native is one of those places where you just have to have a lot of compiled code. Those lil phones try hard, but battery life being what it is, performance is a factor. Javascript can only go so far. Especially for consumer development, when you are going to get taken to the woodshed if somebody's piece of junk twenty dollar android special can't hold it together.
Also, check out Xamarin Workbooks for a good demo of how developing with a compiled language can actually be interactive.
Meanwhile, check out Flutter: https://www.youtube.com/watch?v=Mx-AllVZ1VY
You can build your code deltas and re-deploy your app, even restarting the current Activity you were on before.
This has made worlds of difference for me when tweaking custom, finicky UI pieces as you describe. It's on the same order of magnitude of speed as the web devs F5-ing their browsers.
I'm not sure where the author's coming from, but the IDE seems fine to me. I use IntelliJ at work, so that's what I'm used to. Maybe there's stuff that an actual Android developer would have issues with -- more advanced features, but I thought that the tool was leaps and bounds better than the Eclipse extension that used to be supported.
You seem wholly unqualified to make this type of judgement
But I will say that if someone is accustomed to A, and they are forced to use B for a short period, it is incredibly common for those users to bitch and gripe about how terrible B is simply due to lack of acclimation. The fact that they develop for Android infrequently makes their observations less valid to me, not more.
Yes, Android Studio requires a lot of memory, but welcome to 2017 where entry computers have 8GB. Beyond that, their complaints are whiny "this is strange and unfamiliar and threatening to me" bullshit.
There are real complaints here.
What? How can you declare this after spending at most a few hours in the environment?
And you get all this with Android Studio, too. Let's not forget Kotlin, which might not even exist without JetBrains' involvement in Android Studio.
BTW I sometimes fell back to XCode even when I was a heavy AppCode user, e.g. when the battery was running low. Switching is mostly seamless, because both watch the filesystem and seldomly complain about clashes. Perhaps one could use some lightweight Java editor alongside Android Studio, too?
A significant part of that is because XCode has loads of magic incantations that you have to perform when it starts flaking out (which it does much more often). Caches to clear, library files to delete, etc, sometimes one works and sometimes another does and it doesn't help you figure it out. XCode has such a problem with mishandled caches that multiple community tools have sprung up to aggressively delete it, e.g.: https://www.cerebralgardens.com/watchdog (and they're still insufficient! they just address the most common annoyance)
But it's not debuggable. It's not introspectable. When things go wrong, you're left hoping Stack Overflow has a magic piece of copypasta to save you from days of guessing. To integrate with it you practically need to do what Android Studio has - work directly with the Gradle team to expose enough information to custom-build an IDE that can make use of it.
It feels like it could've been achieved more simply by other means. Instead we have a truly massive, very slow build system that few understand, and for a long time (including after Android Studio's adoption) didn't support basic, long-standing features of the Java build environment (like "provided"-scope code (common in many languages! arguably universal!) and annotation processors).
Don't forget Gradle has the choice of 2 languages to use for configuration -- Kotlin and Apache Groovy. If you use Kotlin you get:
* full Android Studio support for auto-complete hints because Kotlin is statically typed, and Kotlin and Android Studio are both created by the same company, i.e. Jetbrains. (Groovy is dynamically typed and auto-complete only works 80% of the time.)
* Kotlin can also be used to build actual Android apps instead of Java, so you can use the same language for building the app and writing the scripts for builds, tests, etc. (Groovy had Android support added, but 2 yrs ago the programmer who do it was retrenched from VMware and no other business wanted to hire him to continue the work, so it's a bit dated.)
It still feels like doing MFC windows app in some ancient Visual Studio.
Why can't all new GUI IDEs start at least at level that Delphi was 20 years ago?
I want to feel that I'm in control of building an app.
Android Studio (and Eclipse before that) made me feel like I'm taking unguided tour over bad decisions of android API creators and lack of giving a damn of IDE creators.
Delphi 1: https://winworldpc.com/res/img/screenshots/1x-1a684e073c9048...
Delphi 10: http://uimg.in/images/2017/01/05/e4vC6sN.png
When I break apart the UI differences it's obvious delphi's UI had to grow to accommodate the growing complexity of the projects built with it, and that delphi 1 could get away with being simple because it wasn't expected to do all that much. Still, when I look at that delphi 1 screenshot all I can remember was how fun it was to program in it.
Conversely, it's also surprisingly easy to just install and run with, though it does take time to download all the components and the first Gradle build can take a while if your machine is older.
The first time I used it I was shocked at how painless it was to get going (I came into it expecting it to be an endless nightmare of configuration and headaches a la Eclipse).
I continue to use it occasionally and without trouble on a more than three year old Inspiron 3000 with only 4 GB of RAM and a cpumark score around 1700. (Of course I'm also not really using the emulator on that machine and just debugging on an actual device.)
I've also almost never used the visual layout editor (after seeing that is existed) just because the layout system reminded me of flexbox and CSS, so I felt comfortable just writing layouts. So maybe it's bad, but I've also never felt like I needed it.
Could it be better? Probably. Is it completely terrible? Not really.
Maybe we should stick to only posting techcrunch articles about finance or insider startup news, and find better sources for critiques in development environments.
I've been building Android software since about 1.5, and these days I can't even create an empty project that builds with Google's toolkit
-> create an empty project, hit build, get weird gradle error messages, .so issues, compilation problems, internal IDE errors, UI previewer doesn't work due to some old .jar that gradle has pulled down, and so on.
and pressing "build" takes 60 seconds on an empty project!
vs. the old ant system that seemed to work out of the box, and would build under a second
(and I pay the Jetbrains subscription for IntelliJ for my non-Android work! and love IntelliJ!)
I use AS every day, and have been since it was 0.8. It's powerful and makes everything I do easier. About the only point I'd give him as accurate is that you've got to have the powerful laptop to run it.
I find BOTH of them to be much more difficult than I feel like they should be. Many things in each are not intuitive.
1. the platform does far more than just java as well.
I don't do Android development but I've fired up Android Studio to look at android code another team writes from time to time but with the above statement you lost me 100%. IDEA is awesome and and I gladly pay for it. It is, in my opinion, the best IDE out there right now.
I personally think that AS/Intellij are the best IDEs I've ever used. That includes Visual Studio Pro.
The article seems to be complaining about WYSIWYG not working well, and slow emulators. I've never found WYSIWYG to be an acceptable solution, but that's just my opinion. But to throw the whole IDE under the bus because of that is just irresponsible.
Also the emulators are blazing fast on my machine.
Personally I think it has a few rough edges (memory/CPU usage, designing weirdnesses) but it's mostly fine. It's Android development itself that still has some pointy bits, especially in regards to building and dependencies.
Like the Tools > Android thing. Not the best design decision? Sure. But jesus christ does this guy seem to hate that. A lot of us grew up using programs like this and I find the location of the Android submenu in Tools to be perfectly fine. I mainly use IntelliJ for Ruby and all my Ruby tools live in the Tools menu too. If you understand IntelliJ as a Visual Studio-style polyglot platform, then the design makes sense. If this guy would take a moment to understand what he is working with, perhaps he would have much less difficulty.
Android is better for testing and distribution but sucks at development (well, that's natural given that everything is written in f..ing Java, I've never seen a Java application that is both complex and fast/resource-saving), and Xcode/Apple is better for development but sucks so much for delivering, even for testing.
If you know what to do then AS is pretty great. If you want to compare it with xcode then xcode is a sad state of affairs imho, lacking a lot of features that AS has.
It was a bit painful to have to see my ios colleagues have to resort to textsearch to find out where a certain member was being accessed, i mean come on.
The little ios dev I still do I do in Jetbrains' AppCode. Much better for actually coding.
I can imagine. Especially when it's one of the few features that actually exists in Xcode.
My biggest gripe is more to do with the language. It's somewhat surprising how a company which can invent a simple language like Go created a monstrosity like the Android API, and while I understand that in the first couple releases they had no choice and no experience, I would have expected them to rethink their API model in post-lollipop.
My personal gripes:
1. Lifecycle management - how many entry points are there into your app?
There should be an entry point (app started) and one exit (app ended). And don't get me started on Fragments.
2. Callbacks - Why Why Why WHY?! I understand that closures are a new feature and were not available for most of Android's cycle, but inner classes are so ugly, I'd rather write it manually (using a single on-event function with a switch/case on events firing) than use inner classes.
3. Not fully OO. Why can't I pass object around? Why only strings?
4. File/Stream dichotomy - Some things are done by file, others by stream.
5. Library - Practically, almost all modern "Native looking apps" (meaning, not Q or OpenGL based) rely on appcompat, and will always require appcompat (Google recommends using AppCompat even if you're not targeting old phones, since they fix bugs in AppCompat which they can't in Android). So why make a "native" library? Keep the basic "native" library small and keep the code in appcompat?
Eclipse, on the other hand...
When I had a choice years ago to go down the Java path or the .Net path, I chose the .Net path partly because of the quality of the development tools. Also I trusted MS to evokve the language more than I trusted Sun and now Oracle.
I launched Android Studio and it still had the "Java stink" to it that all Java based GUIs have.
But XCode and IOS development definitely is a lot more polished experience than Android development.
I use Android Studio, Xcode and Visual Studio daily. I prefer Android Studio by a mile because of the great integration with testing, build tools and command line. It's slightly more productive than Visual Studio, and both Visual Studio and Android Studio are leaps and bounds better than Xcode which spends 10 minutes trying to make sense of C++ code and then crashes when you scroll around a storyboard while throwing up bouncing colored doom balls every few minutes.
EDIT: Choosing a job because of those things sounds like something you'll regret in the future. There are far more important considerations than 'Java stink'.
After using R# everyday with Visusl Studio for years, I got a job that wouldn't provide Resharper for developers. I bought it myself without a second thought. I want the tools I use to be seamless as possible.
As far as the other reason I chose to base my career on .Net rather than Java once I decided to move away from C++ bit twiddling - that I trusted Microsoft to evolve the platform more than Sun, in hindsight it seemed prescient.
At the end of the day, all that matters is what matters to you.
Visual Studio > XCode > Notepad > driveway chalk and a hose > Android Studio > Eclipse
I'll say it, I vastly prefer Android Studio over XCode. And I'm an Android Developer who uses Android Studio every single day.
I do like Visual Studio a lot as well, it has been a nice experience for all of the times I've used it. But I prefer to develop in the languages and environments supported by IntelliJ + Android Studio (Java, Android, Ruby) over Xamarin-based .NET work available in Visual Studio.
Android Studio I probably like better than XCode because it feels more akin to Visual Studio. XCode I really want to like, but it feels incredibly foreign vs Visual Studio-like UIs. Though I hear people that love it, so there you go.
There are indeed some issues with Android studio mostly related to visual design but I have never found that to be a handicap because you are generally better off hand coding all your layouts.
I would love to see tighter integration with Firebase, Azure and AWS though something that is missing right now.
And yes, it got a lot better year after year too. Everyone's experiences vary I guess. I personally don't like most of the heavy IDEs for Java.
See "Is XCode 8 the worst release in recent memory, or perhaps ever?" https://www.reddit.com/r/iOSProgramming/comments/54r9ro/is_x...
I can understand why someone who opens it twice a year would think this way though.
Theres is commented out line in one of the grade flies about HEAP size, I read about uncommenting it & poof my build times noticeably reduced.
And buying IntelliJ is only $150. Everybody has their own calculus of convenience versus money, but for me at least, that hits a spot where better tools and the time I save is more valuable than the money they cost.
If only Google could come up with a name for Android Studio that annoyed Oracle that much.
Personally I'm going to skip Android Studio and wait until Google changes their mind again and moves to a new IDE. Should be only a year or so. ;>
I have to configure Studio in laptop mode and prune several pkugins, to have a similar performance level.
AS is an enormous RAM hog, for instance. I have the space, so I prefer that - unused is just wasted. But it's wholly incapable of running on lower-end hardware that can run Eclipse just fine.
Unless this is a side-effect of Google's doing.
My PC runs VS 2015, Eclipse and Netbeans just fine.
I mean, I mostly like it that way - I'm not saying that's a bad thing. The more my IDE can do for me the better, and there's rarely a reason to remove those abilities. But it has costs.
The delay between typing and actions is just too much.
Maybe I'll try it again when Android Studio v3 comes out.
The goal of the project was to control a Lego Mindstorms via Bluetooth, over a attached Android Smartphone which can be remote controled by a WebInterface...
Luckily someone else did this allready, http://www.smartlab.at/articles/android-wifi-htm5-nxt-robot-... so I thought I can just import his Project and then start modifiying it a bit ...
I was curious if I could manage it, without reading a Tutorial or doing a Hello World for Android or something similar first ... because I have some Java and Eclipse experience and Android is basically just Java, right?
In the end, well, yes I kind of managed - but it took me about 4 hours messing with configuration files and reading help sites, before I had the whole project running (and not stable, though)
Main problem was, that the Project I used was quite old and for Android 2.2(which I did not know in the beginning) and Android Studio just imported it without warning, but ignored all the old configs and just set the sdk of the Project to the latest Android - and therefore just didn't run on, nor connect to my old Android 2.3 nor 4.x Devices - without telling me why not)
Otherwise, many things did worked out of the box (that means after a lot of downloading and waiting and then downloading again ...) and in a expected way ... and unlike what some people here think, I had the impression, that there was indeed quite some work and polishing behind it. (yes, IntellIJ seems nice) Even though - it did felt adopted to and not made for Android in many situations.
And it is slow.
So very, very slow.
And even though the hardware I used, is quite old, other IDE's like Visual Studio(Code), or my main tool: Chrome Developer Tools, run fast enough.
And the UI is unfortunately not very intuitive. Too much buttons and information, I did not needed for the tasks I had and the ones I did needed were allmost burried under all that mess. In the end I usually found, what I searched for and it never took too long, but probably more because of my previous Eclipse(and similarish)-Experience, than because it was where I would expect it intuitively.
So to summarize I would say, it is indeed quite better than how Eclipse was in my memory, and I disagree with "gruesome embarrassment", but still, I am so glad, I don't have to actually work with it ... and I decided to not use it any further and rather do the mindstorms project again from scratch, but with HTML5. But this also might be, because I never really liked Java in the first place, so Android Studio maybe did not had a real chance to change this. But while thinking about it, it is also very possible, that I never enjoyed Java programming BECAUSE of Eclipse/NetBeans...
Lots of the SDK feels poorly-thought-out, even relatively recent additions.
Some things that exist for both Web and Android are worse on Android, inexplicably (Location for instance).
Lots of Googling a problem, finding a bug report for it from 5 years ago, and reading in the comments saga of "not a bug, intended behavior", "no, seriously, it's a bug, learn to read (x10)", then a stretch of months of "will you please fix this? It's a big problem.", "here's a workaround", "thanks!", "here's the fix, it's a trivial 2-line change, please pay attention Google!" then a silent "CLOSED DUE TO BUG BEING OBSOLETE", then several, "but wait, this still happens in the latest. Do you guys even test?", the last of which dates to a week ago.
[EDIT] Oh, and mediocre technically-complete-is-the-best-kind-of-complete documentation full of bad examples (to the point of being outdated and broken, sometimes) and bad advice.
Guy seldom uses tool, thus finds it illogical and confusing. Story of every casual user in the history of time. I seldom use XCode or OSX, and I find both of them to be unintuitive messes, yet I have the wisdom to realize that's mostly just lack of acclimation.
If you get the feeling IntelliJ is a 15 year old software because it is slow, you should upgrade your computer. Get at least 8 gigs of RAM, an i7 or equivalent processor, and an SSD. If you do programming to earn your livelihood, that is a far better investment than switching to a text editor for speed.