Sooner or later in the life of every developer there comes a moment when they have to decide which field of technology seems the most interesting to them and find out which tools allow them to solve certain problems. The most important is a programming language which supports specific solutions and platforms, thus defining the way of working.
In this article, I am going to tell you why Android has become my platform of choice and (perhaps) I will help you make your own decision.
The Advantages of Programming on Android
A wide range of applications
Android is an operating system you surely associate with portable devices such as smartphones or tablets, however, it applies to a much wider spectrum of devices such as:
- Android Auto – a car travel assistant;
- Android TV – a system for digital multimedia players (DMP). It has replaced the Google TV platform;
- Android Things – a platform for building IoT devices;
- Wear OS – a system for wearables (including smartwatches and smart bracelets).
Every programmer can find something that interests them: mobile banking applications, systems designed to handle household appliances, or programs to make life easier for people with disabilities – there is a lot to choose from.
Regular updates
Officially, the first generation of mobile phones running this system went on sale in October 2008. For nearly a decade, the Android system has had eight major versions. The latest update, numbered 9.0 (fun fact – the major version history names are all based on sugary treats such as Cupcake, Donut, and Ice Cream, Sandwich), is the twenty-eighth instalment of the application programming interface (API). This means that the system is constantly being improved both in terms of correction of possible errors and implementation of technological innovations.
Established market position
Smartphones with the Android mobile system have been, since 2010, the most popular devices of this type. In 2017, around 1.3 billion smartphones with Android OS were sold worldwide, which accounts for 85.9% of the market share (1.1 percentage point increase compared to 2016). The customers’ high interest in Android devices translates to high demand for development-related services and thus the stability of employment supply in this profession, as well as the potential to earn a high salary. Initially, the system was developed by Android Inc., but after a few years, the project became a part of Google.
A certain advantage of Android over rival solutions is its availability (due to the price of the devices) and openness (due to access of the source code, which can be downloaded and modified free of charge). As a consequence, device manufacturers pay less for system implementation – and they can modify the OS to suit their own needs.
Availability
Android can be installed free of charge on devices offered by many brands, both on low-cost low-end equipment and on flagship smartphones from companies such as Sony, Samsung, and LG. As a result, novice programmers can buy hardware with the system at a low cost and test the solutions they develop easily.
Maturity of components
Because the Android platform has been available to developers for several years, programmers have access to many mature libraries which improve the application “writing” process and without many of them, it is hard to imagine working. I know from my colleagues who are iPhone developers, that for iOS, such a robust resource does not exist.
Application Development Tools for the Android Platform
Basic applications for the Android system, and I do not mean three-dimensional games or applications that use augmented reality solutions, are developed using the following tools:
- Java and Kotlin – object oriented programming languages which have received Google’s official support.
- Java JDK – an environment containing, among others, a compiler (a magic program which translates code written by a programmer into code understood by a particular machine).
- Android SDK – a software package containing an emulator (to enable testing applications without a physical device) and a debugger (to analyse a running program to find bugs).
- Android Studio – an integrated development environment (IDE) based on the IntelliJ IDEA solution by JetBrains (authors of the Kotlin language). In this program’s text editor we write code. This application enables integration with the Git version which controls the system. Initially, applications for the Android system were written using a plugin for the Eclipse program.
- XML – a markup language. We will use it, among other things, for building graphical user interfaces (GUI) and defining text strings for specific language versions of applications in a convenient manner.
- Groovy and Gradle – a scripting language and a project-building tool.
Beginnings of the Android Programming Journey
As part of my university course, I had the opportunity to learn programming languages such as Python, C#, and Java. I chose the latter of the languages mentioned, because it was popular and there was a lot information available about it. According to data prepared by TIOBE (which specializes in assessing and tracking the quality of software) it is currently the most popular programming language. Consequently, there is no problem finding valuable courses, books, and help at Stack Overflow. Another big plus is the multiplatform capability of Java Virtual Machine (Java Virtual Machine, JVM), which means that, once written, the code can be run on a write-once-run-anywhere basis, i.e. operated on various operating systems, including Microsoft Windows, macOS and GNU / Linux distributions.
A substantial proportion of programmers begin their source code writing journey with designing and developing simple console applications. These types of programs communicate with the user via commands entered from the keyboard. As you can easily imagine, looking at a white text on a black background is not a particularly exciting activity – there is just… something missing. At some point, after reading a few chapters from the book “Core Java Volume 1 – Fundamentals” by Cay S. Horstmann and making a few simple programs, I came to the conclusion that what is missing is all kinds of tables, coloured buttons, charts, and windows which react to actions taken by the user. All this is what Swing and JavaFX for Java offered. Using these solutions to create a graphical user interface for desktop applications gave me more and more satisfaction. The next logical step was to browse through job postings for Java programmers. It turned out that there are many offers, but almost all of them concerned the Java platform in the Enterprise Edition variant (Java EE; the current name being Jakarta ee). As a result, instead of the Swing concept, the adverts mentioned Spring, but that is a different kettle of fish (Swing is a tool to enable the implementation of a GUI; Spring is a framework to facilitate the development of business applications on the Jakarta EE platform). In addition, a good knowledge of the Hibernate tool for executing data layer access tasks (including object-relational mapping, ORM) was required. In a word, it had little to do with the frontend – and I had absolutely no interest in the backend at the time.
An ideal solution was to choose the Android platform mentioned earlier. Because of my interest in the subject, I completed one of the courses available at the time on the Udacity platform. Also, my university course, which included classes in Mobile Programming, enabled me to deepen my knowledge in this area. As it turned out, my previous experience with the Swing library made it easier for me to understand typical issues of the Android platform. What I mean here are problems related to managing the GUI components; event handling (such as pressing a button or selecting an item from a list), changing the displayed text, or building forms.
With this new acquired knowledge, I was ready to take on the job of an Android Developer. Working on commercial projects for a company has allowed me to develop in many areas, such as: writing clean and testable source code, using design patterns, working with the Git version control system, etc. In hindsight, I think it was a good decision to stay with Android.
Android programming languages
Until mid-2017, standard applications for the Android platform were developed using the Java language. This mature language has nearly 25 years of history. Throughout that time, it has been used in many fields of computer science, including server solutions and applications for devices such as Blu-ray players and printers. However, after the initial fascination with the Java language, the list of objections has steadily been growing bigger. Some of them are:
- The need to write many lines of code to present even the simplest idea;
- No built-in mechanism to prevent calling methods on variables which do not point to any object (null value);
- The need to write cumbersome utility classes in order to extend the functionality of existing APIs.
Gentle irritation, a sort of jealousy even, began to appear when my associates started showing me the Swift language, used in programming applications for iOS and macOS operating systems. Sometime later, I came across the Kotlin programming language, which is something like Swift for the Virtual Machine (JVM). The growing interest by both our team leader and the Android community in the new tool strengthened my conviction that learning more about it is the way to go. I bought the book Kotlin in Action, watched several presentations, and started writing my own code. And suddenly…
this source code:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 |
package com.tobiaszolejnik.example; import java.util.Date; import java.util.Objects; public final class UserJava { private String email; private boolean premiumAccount; private final Date joinDate; public UserJava(String email, boolean premiumAccount, Date joinDate) { this.email = email; this.premiumAccount = premiumAccount; this.joinDate = joinDate; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public boolean isPremiumAccount() { return premiumAccount; } public void setPremiumAccount(boolean premiumAccount) { this.premiumAccount = premiumAccount; } public Date getJoinDate() { return joinDate; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; UserJava userJava = (UserJava) o; return premiumAccount == userJava.premiumAccount && Objects.equals(email, userJava.email) && Objects.equals(joinDate, userJava.joinDate); } @Override public int hashCode() { return Objects.hash(email, premiumAccount, joinDate); } @Override public String toString() { return getClass().getSimpleName() + "(" + "email=" + email + ", premiumAccount=" + premiumAccount + ", joinDate=" + joinDate + ')'; } } |
can be replaced with:
|
1 2 3 4 5 |
package com.tobiaszolejnik.example import java.util.* data class UserKotlin(var email: String?, var isPremiumAccount: Boolean?, val joinDate: Date?) |
And calling several methods on an object:
|
1 2 3 4 5 6 |
if (viewGroup instanceof LinearLayout) { LinearLayout linearLayout = (LinearLayout) viewGroup; linearLayout.setBackground(ContextCompat.getDrawable(viewGroup.getContext(), R.drawable.background_grey)); linearLayout.setShowDividers(LinearLayout.SHOW_DIVIDER_MIDDLE); linearLayout.setDividerDrawable(ContextCompat.getDrawable(viewGroup.getContext(), R.drawable.divider_grey)); } |
can be presented in Kotlin in a more elegant way:
|
1 2 3 4 5 |
(viewGroup as? LinearLayout)?.apply { background = ContextCompat.getDrawable(viewGroup.context, R.drawable.background_grey) showDividers = LinearLayout.SHOW_DIVIDER_MIDDLE dividerDrawable = ContextCompat.getDrawable(viewGroup.context, R.drawable.divider_grey) } |
And the most interesting and useful thing about Kotlin is that it is fully compatible with code written in Java. This language has several advantages over Java. Kotlin makes it possible to write more concise source code and safer applications.
To my satisfaction, in May 2017, at the Google I/O conference, Kotlin has been nominated an official programming language for applications designed to run on Android. I can still remember the prickle of excitement I felt at that moment. Later, it got even better. The Kotlin boom happened. The name of the language began appearing in job advertisements – and not just in the “nice-to-have” category. At Appchance, we have started developing all new projects using the Kotlin language too.
And at this point, you probably want to ask the following question: if this new language is so cool and hip, does it mean I can forget Java? Not exactly. The lion’s share of libraries and programs developed for Android are still written in Java. This means that if you want to get started smoothly with existing projects, you have to know both programming languages. Novice programmers should keep this in mind.
To make the process of transitioning to a new language easier, let me mention a tool for converting code written in Java into the Kotlin language code in a few mouse clicks. It is integrated by default in the current versions of Android Studio and IntelliJ IDEA environments. On the other hand, people interested in developing applications and games that use more advanced 3D graphics, as well as whenever a very high standard of program performance matters, should seriously consider learning the C++ programming language.
Future and alternatives
At present, it is difficult to imagine that the popularity of an operating system with a position on the market as strong as Android’s could drop rapidly in the near future. Currently, the only viable alternative to this environment is the iOS system I have mentioned previously. In addition, many tools, such as Flutter (Google), React Native (Facebook), and Xamarin (Microsoft), enable writing cross-platform applications. In this case, a large part of the code is written once, in a specific programming language, and can be run on different operating systems (e.g. Android and iOS). For more useful information on hybrid and native applications, refer to the article “Native vs Hybrid – what kind of mobile application to choose?”.
It is worth mentioning that Google is currently working on a system called Fuchsia, which may replace Android in the future. Applications for it are to be written in the Dart language. At the moment, however, I think that programmers who know Java and Kotlin do not have to worry about having to retrain soon 😉
To sum up. If you are still wondering whether programming for the Android operating system is a fun adventure, let me answer you: It is. And if you still have any doubts, I will gladly post some links to courses and books. 😉
You might also like
Increasing mobile app retention focuses on the users returning…
