Why has Google failed to get Android development on track?

Introduction

It's 2015 now, mobile is the new frontier, and we seem to have emerged from the nightmare of the chaotic past - yes, the poor performance of mainstream websites in delivering content to mainstream mobile devices is still vivid today, and every developer should remember the desperate mess at that time. If web development represents all the dirty and bad elements of the 1990s, then mobile development today is the new carrier of the ugly effects of the new era.

Just as IE is the new IE for web developers, Android is now the new IE for mobile developers. Google has used all its resources to push it to the top of the market share, and its position as king of the hill seems unshakable. If you want to expand into the mobile market, ignoring the Android platform is undoubtedly a suicide act from a business perspective.

Android development is weak.

Android development mechanism has always been plagued by problems. Programmers are usually reluctant to develop applications on the Android platform because they need to consider too much - just like Web developers hated IE in the past.

There have been countless blogs on the internet about the endless suffering that many developers have to endure because they are forced to develop for the Android platform. Needless to say, I believe that everyone who has experienced this can understand it.

From installation to environment setup, stupid and over-designed engineering SDK, device fragmentation, and even the documentation cannot reach a unified content, all of this makes me feel headache. I don't want to evoke my personal or everyone's painful memories in today's article. Instead, I hope to explain this situation in other ways. What if I tell you that Android development doesn't have to be so annoying? What if I tell you that there are other ways to achieve it?

Another way, the Python way

Wouldn’t it be exciting if we could complete the overall setup of the environment with a few simple commands?

 sudo add-apt-repository ppa:kivy-team/kivy
 sudo apt-get update && sudo apt-get upgrade
 sudo apt-get install python-kivy

Would you be happy if you no longer had to install and configure a bloated IDE, but could open the code directly in a text editor and modify it (using a more concise and clear language)?

   import kivy
 from kivy.uix.widget import Widget
 from kivy.app import App 
  
  
 class HomeScreen(Widget): 
  
  
 def button_clicked(self):
        self.ids.home.counter += 1  
        self.ids.label1.text = "you clicked " + str(self.ids.home.counter) + " times!"   
  
  
 class MyApp(App): 
  
     
 def build(self):
 return HomeScreen() 
  
  
 if __name__ == '__main__' :
 MyApp().run()

What if, whenever you need to build a graphical user interface, you can do it using a simple and clear DSL?

 <HomeScreen>:
 BoxLayout:
       orientation: 'vertical'  
       size: root.width, root.height
 id: home
 counter: 0   
        
 Label:
 id: label1
           text: 'Hello World!'   
 
 Button:
 id: button1
 text: 'click me!'  
           on_press: root.button_clicked()

How would it sound if you could just run your application directly when you need it, without the need for any emulator?

 python main.py

What if, when you need to deploy your application, you only need to plug in your mobile device and use the following simple command?

  sudo apt-get install python-pip
 sudo pip install buildozer
 buildozer init
 buildozer -v android debug deploy

What if you want to deploy your app to iOS with just the following command?

 1 buildozer -v ios deploy run

This is not just a dream, in fact Kivy and Python can do this today, and thanks to the high-level APIs, they can even do things like access GPS - and like any good API, this is all done in an abstract way.

Summarize

Kivy is a fantastic cross-platform multi-touch GUI programming project. It is exactly what my ideal mobile development tool should be like. Simple and direct, easy to develop and easy to deploy. And don't worry, you can use it to build excellent applications that can run across platforms at the same time.

So why can't Google come up with an equally ideal solution? Keep this in mind:

Any clever fool can solve the problem in a larger, more complex, and more brute-force way. But to come up with a solution the other way around requires a combination of genius and courage. (Einstein)

I believe that one day mobile development tools will have all the advantages of Kivy, but in a native and unadjustable way. And when that day comes, it will become the new king of the hill - it will ascend to the throne not by the full support of giant enterprises, but by the firm support of developers.