Go to main page
A journey into the programming realm
The point of no return
Leaping into the unknown
Mobile development refers to any kind of development that is performed for a mobile device.
AMP is a project designed to allow web pages to load faster, so users can get their content almost instantaneously.
This whole idea is to get the text to the user as fast as possible, so things like images, html tags, forms and others are either not loaded, or loaded when the user scroll them into view (lazy loading).
Native applications are smartphone applications coded in a specific programming language, used specifically for that mobile’s operating system, such as Objective C / Swift for iOS or Java for Android.
Through these languages, we can use the tools that the OS vendor provided to us for development.
Native applications provide great performance and allow the programmer to access various devices from the phone.
The problem with such apps is that they are bound to the operating system they are written for, so you have to rewrite the code for your application if you want to have it available for both iOS and Android.
There are some cross-platform solutions which will compile the final code up to the native format and hook directly into the native APIs. This way, you can write your application in another language (e.g. C#) and get all the benefits of a natively-built application, and make it compile for all mobile platforms.
There’s also a solution for multi-platform functionality, by using a web-based mobile application.
Therefore, you will have most of your data on the server, and the mobile will fetch it from the page.
Most of mobile devices have motion sensors (accelerometers, gyroscopes) or environmental sensors (temperature, pressure). These devices usually have a sensor library which can tell you which sensors are available on a device, and can be used to access such sensors and acquire the raw data from them.
Mobile devices provide you access to the current location of the device, but in order for that to work, the application have to request permission from the user.
Battery is very important to the user, and if you care about their experience, you should know how to make your application use as little battery as possible.
Would you use an application, even if it’s fantastic, if it drains the battery so that the phone is unusable after 1-2 hours, or you would uninstall it?
The activity class provides a number of callbacks that allows the developer to know when the state changes.
The system will automatically invoke the callbacks that were registered when the activity enters a new state.
| Event | Action |
|---|---|
| onCreate() | fires when the system creates the activity object, in which you should perform basic application startup logic that should happen only once. |
| onStart() | fires when the activity enters the started phase, for example when the activity is visible to the user |
| onResume() | fires when the activity comes to the foreground, for example when the user navigates from another application to ours. |
| onPause() | fires when the activity is moved to the background, for example when the user navigates from our application to another one. |
| onStop() | fires when another activity takes its place, for example when we change from one screen to another. |
| onDestroy() | fires when the activity is destroyed. |
A fragment is a portion of a user interface, with its own lifecycle and input handlers, which is dependent of an activity and the activity’s lifecycle.
You should know how to debug your Android application and chances are you’ll be using Android studio so you might as well learn how to use the debugger provided by it.
A task is a collection of activities that are required for a specific job.
The back stack is basically a stack of tasks, so that the user can go to the previous screen by pressing the back button.
The context is simply a handle to the system. It provides access to services such as resources, databases, preferences, and so on.
As a programmer, you’ll obviously want to learn how the threading works in Android.
The main thread exists, obviously, and is in charge of dispatching the events to the appropiate user interface widgets.
There are methods that respond to system callbacks to report some user actions or a lifecycle callback method that always runs in the UI thread of the process.
Manipulation of UI elements should always be performed from the UI thread.
The content providers are the standard interface that connects the data from one process with another process, help an application manage access to the data it stores, and provide a way to share such data with other applications.
When you run a time consuming function on the main thread, it blocks other actions from happening, and for the user, it looks like the application has frozen.
If an action is performed by the user while the UI thread is blocked, and the application doesn’t reply fast enough, the system will display a dialog letting the user know that the application is not responding.
Therefore, you should know how to use the Android threading to execute such functions on separate threads.
A service is an application component that can perform operations in the background, continuing to run in the background even if the user will switch to another application.
Custom views refer to designing the application as you’d like: By selecting from different layouts, and adding widgets onto the screen, such as buttons, forms, galleries, and many more.
Core data is the framework for storing data on Apple devices, including persistency.
Grand Central Dispatch is a library that provides support for concurrent code execution.
Views are the fundamental building blocks for the user interface. A view object renders content within its bounds and handles any interactions that occurs on the object. If you decide to build custom views to display the content, you must handle all the touch events that occur in those views yourself.
Alerts / Notifications are also part of the views, and they provide information to the user, or request feedback from it – basically they are popups with an optional message, and one or more buttons, or even a text field for input.
UIViews are similar to activities for Android – developers can override the methods of interest to add some logic at the appropriate time.
| Method | Action |
|---|---|
| Init() | is the method that gets called to instantiate the view controller. The function is called only once during the life of the object. |
| viewDidLoad() | Is the method called after init(), when the view is loaded into memory. The function is called only once during the life of the object. |
| viewWillAppear() | is the method called just before the view appears on screen to the user. |
| viewWillDisappear() | is the method called just before the view disappears from the screen. |
Artifacts are anomalies that are present during the visual representation of a graphical object. Can appear due to software bugs, overclocking the video card, driver-related issues, temperature of the hardware, etc.
Null object pattern/idiom is used when working with pointers. Instead of setting the pointer to null and verifying if it’s null, or doing a null pointer dereference by mistake, we provide a default implementation that does nothing when functions are called.