Tag Archives: google

Guidelines to Avoiding Google’s Penalty Caused by Intrusive Interstitials

Intrusive interstitials guidelines to avoiding google's penalty

This year, Google has made one recent change known as the intrusive interstitial update. This update aims to penalize intrusive popup ads which affect the mobile user experience. No wonder that some websites have experienced lowered mobile rankings. If you are working in SEO service field, this thing may become one of your concerns. But, don’t worry as you can avoid Google’s penalty caused by intrusive interstitials. Figure out the solutions in the passages below.

Decrypting the Intrusive Interstitial Update
First of all, it’s a mobile popup penalty.  Secondly, it’s an intrusive popup penalty. In light of this, Google wants to make sure that ads and popups do not interfere with the user experience. By devaluing pages with popups and overlays on the screen, Google can help users access the content they’ve requested in the first place.

What is the Impact of this Latest Update?
Pages with intrusive interstitials will no longer consider as being mobile-friendly. This is because obstructing content on mobile with ads or other popups is against Google’s guidelines. Ads or popups on screen causes the content inaccessible for a few seconds. In fact, Ads displayed over content are no longer acceptable on mobile. This includes popups that appear when you load the page from Google or when you scroll down.

What Constitutes an Intrusive Interstitial?
Intrusive interstitials will lead to a frustrating experience for desktop and mobile users alike. In fact, it tends to block most or all of a page. This will hinder visitors from experiencing your site as they block the content that visitors seek unexpectedly. In light of this, intrusive interstitials has become the biggest enemy as on desktop they are annoying at best and can ruin the entire experience on mobile.

What is still Permitted and not?
Even though, you have to deal with pop ups ads, but this doesn’t mean that all pop ups are forbidden. In fact, some popups are still permitted, such as:

  • Intrusive popups are still ok on desktop
  • Interstitials triggered by exit intent are still allowed
  • Page to page interstitials will not be penalized

Types of intrusive interstitials that will be forbidden are:

  • a popup or modal window that blocks most or all of the content on a page (this is basically a full-screen interstitial above the header);
  • a standalone interstitial that’s not responsive and that blocks the content;
  • a layout in which the content above the fold has the look and feel of an interstitial and requires dismissal or scrolling in order for the user to reach the main content beneath the fold.

Workarounds
Popups is frustrating indeed, but companies use them as at some points they are effective. So, if interstitials still become the best options to convert users for your websites. You can consider keeping them on the website by a no-index tag in your code. However, this will cut off organic traffic from Google to that page.

Therefore, designers, developers and marketers must create another ways to generate revenue. A sound strategy would be to leverage content marketing to educate audiences and guide them through the buying process. In the other words, you should move away from interruption marketing towards permission marketing.

So, the solutions that you can do related to this situation are; audit your popups, cookie notifications, overlays and big banners. This is to make sure that they comply with Google’s new guidelines. Furthermore, make sure that don’t take up space more than 15% from the screen to avoid penalty.

Why Machine Learning, Limited Organic Space, and Voice Search can Cause the Death of Organic Search?

voice search

As google will always update their search results, the work of SEO services in maintaining client’s rank site is a never ending process. Recently, many webmasters have noticed that some changes have caused the death of organic search. This includes machine learning, limited organic space, and changes in voice search. So, why these three areas can interrupt your organic search result? Here are the reasons:

  1. With hummingbird algorithm, Google is able to understand conversational language better.
  2. Before the existence of machine learning, Google could address device, location, personal preferences, and etc. But with machine learning, all these things can be addressed quickly and effectively.
  3. There is only less space for organic results in the traditional desktop and mobile formats as the space is shrinking. In the end, it makes the organic result less visible.
  4. Paid listings get more space in the search result.
  5. Mobile internet users have surpassed desktop and will keep increasing.
  6. Voice search users grow quickly.
  7. Personal assistant will be added to all modern Android devices.

All of the above reasons show that with so many algorithm update, Google is getting better and faster at understanding the data. In fact, Google even improves their understanding of conversational language which the result now becomes more excellent.

In the end, all of the facts above don’t mean that SEO is entirely dead it just that it doesn’t look like it does now. So, it’s a time for us to start thinking about how your site should appear and what you can do to improve it. Here are a few suggestions for heading into a brave new world.

  1. Create content that will rank for Q&A and informational queries.
  2. Searcher’s eyes are going to change dramatically and therefore, the quality indicators will also change along the way. Providing the best possible product images, information, videos, guides, etc. will be what separates the results. There will likely be result sets closer to an image search result than a typical SERP now for e-commerce queries, and other query types will likely also change. Staying on top of these changes will be more critical than ever.

 

The Activity Lifecycle of Android

The-Activity-Lifecycle-of-Android_1

In Android activity lifecycle, there are four activities that permit the activity to know a state has changed. They include creating, stopping or resuming an activity or destroying the process in which the activity resides.

Through activity lifecycle concept, web developers and android developers can learn to understand how your activity works properly when the user leaves and re-enters the activity. This means each callback permits you to perform specific work that’s appropriate to a given change of state. Doing the right work at the right time and handling transitions properly make your app more robust and performant. By having good implementation of the lifecycle callbacks will ensure your app keeps away from several things bellows:

  • Consuming valuable system resources when the user is not actively using it.
  • Crashing or losing the user’s progress when the screen rotates between landscape and portrait orientation.
  • Losing the user’s progress if they leave your app and return to it at a later time.
  • Crashing if the user receives a phone call or switches to another app while using your app.

In the next section, we will discuss the lifecycle paradigm and then we will explain each of the callbacks.

Activity-Lifecycle Concepts

The Activity class offers a core set of six callbacks to navigate transitions between stages of the activity lifecycle, such as: onCreate(), onStart(), onResume(), onPause(), onStop(), and onDestroy(). The system navigates each of these callbacks as an activity enters a new state.

Figure 1 presents a visual representation of this paradigm.

diagram

diagram

The chart above shows the activity states, the activity will be more complex depends on your requests. If you only implement a simple activity state, you don’t need to implement all the lifecycle methods. But, you still need to understand all of the lifecycle and implement those that ensure your app runs the way users want.

Lifecycle Callbacks

This section provides conceptual and implementation information about the callback methods used during the activity lifecycle.

onCreate()

This callback is the first stage when the system first creates the activity. The activity enters the created state. You perform basic application startup logic that happens only once for the entire life of the activity, in the onCreate()method. For example, your implementation of onCreate()might bind the data to lists, initialize background threads, and instantiate some class-scope variables. This method receives the parameter savedInstanceState, which is a Bundle object containing the activity’s previously saved state. The value of the object is null, if the activity has never existed before.

To understand fundamental setup for the activity, such as declaring the user interface, defining member variables, and configuring some of the UI. In this example, by passing file’s resource ID R.layout.main_activity to setContentView().

TextView mTextView;

// some transient state for the activity instance
String mGameState;

@Override
public void onCreate(Bundle savedInstanceState) {
    // call the super class onCreate to complete the creation of activity like
    // the view hierarchy
    super.onCreate(savedInstanceState);

    // recovering the instance state
    if (savedInstanceState != null) {
        mGameState = savedInstanceState.getString(GAME_STATE_KEY);
    }

    // set the user interface layout for this Activity
    // the layout file is defined in the project res/layout/main_activity.xml file
    setContentView(R.layout.main_activity);

    // initialize member TextView so we can manipulate it later
    mTextView = (TextView) findViewById(R.id.text_view);
}

// This callback is called only when there is a saved instance previously saved using
// onSaveInstanceState(). We restore some state in onCreate() while we can optionally restore
// other state here, possibly usable after onStart() has completed.
// The savedInstanceState Bundle is same as the one used in onCreate().
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
    mTextView.setText(savedInstanceState.getString(TEXT_VIEW_KEY));
}

// invoked when the activity may be temporarily destroyed, save the instance state here
@Override
public void onSaveInstanceState(Bundle outState) {
    out.putString(GAME_STATE_KEY, mGameState);
    out.putString(TEXT_VIEW_KEY, mTextView.getText());

    // call superclass to save any view hierarchy
    super.onSaveInstanceState(out);

You can create new objects in your activity code and build a view hierarchy by inserting new Views into a ViewGroup. You then use that layout by passing the root ViewGroup to setContentView(). To get further information about creating a user interface, you can see the User Interface documentation.

Your activity does not reside in the Created state. The activity enters the Started State, after the onCreate() method finishes execution. Then, the system calls the onStart() and onResume() methods in quick succession. The next section explains the onStart()callback.

  • onStart()

The system demands this callback, when the activity enters the Started state. In order to make the activity visible to the user, you can use the onStart()call as the app prepares for the activity to enter the foreground and become interactive.

Besides, it also registers a BroadcastReceiver that monitors changes that are reflected in the UI. The activity does not stay resident in the Started state, the onStart() method completes very quickly and, as with the Created state. The activity will enter the Resumed state, once this callback finishes, and the system invokes the onResume()method.

  • onResume()

The onResume() system invokes the callback, when the activity enters the Resumed state. The system will once again calls as onResume() method, if the activity returns to the Resumed state from the Paused state. For this reason, to initialize components that you release during onPause(), you should implement onResume(). For example, you may initializa the camera as follows:

@Override
public void onResume() {
    super.onResume();  // Always call the superclass method first

    // Get the Camera instance as the activity achieves full user focus
    if (mCamera == null) {
        initializeCamera(); // Local method to handle camera init
    }

Furthermore, to initialize components that you release during onPause(), you should implement onResume(). Then, perform any other initializations that must occur each time the activity enters the Resumed state.

  • onPause()

To pause operations such animations and music playback that should not continue while the Activity is in the Paused state, and that you expect to resume shortly. There are several reasons why an activity may end up in this state:

  • A new, semi-transparent activity (such as a dialog) opens. As long as the activity is still     partially visible but not in focus, it remains paused.
  • Some event interrupts app execution, as described in the onResume() This is the most common case.
  • In Android 7.0 (API level 24) or higher, multiple apps run in multi-window mode. Because only one of the apps (windows) has focus at any time, the system pauses all of the other apps.

For example, the onPause()method is a good place to release it, if your application uses the camera. The following example of onPause() is the same to the  onResume() example above, releasing the camera that the  onResume() example initialized.

@Override
public void onPause() {
    super.onPause();  // Always call the superclass method first

    // Release the Camera because we don’t need it when paused
    // and other activities might need to use it.
    if (mCamera != null) {
        mCamera.release();
        mCamera = null;
    }
}

  • onStop()

The Stopped state is when your activity is no longer visible to the user and the system invokes the onStop()callback. You can also call your activity as onStop() when the activity has finished running, and is about to be terminated. Below is how an implementation of onStop() that saves the contents of a draft note to persistent storage:

@Override
protected void onStop() {
    // call the superclass method first
    super.onStop();

    // save the note’s current draft, because the activity is stopping
    // and we want to be sure the current note progress isn’t lost.
    ContentValues values = new ContentValues();
    values.put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText());
    values.put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle());

    // do this update in background on an AsyncQueryHandler or equivalent
    mAsyncQueryHandler.startUpdate (
            mToken,  // int token to correlate calls
            null,    // cookie, not used here
            mUri,    // The URI for the note to update.
            values,  // The map of column names and new values to apply to them.
            null,    // No SELECT criteria are used.
            null     // No WHERE columns are used.
    );
}

  • OnDestroy()

This is the final call that the activity receives. Usually this activity exists due to someone’s calling  finish(), or because the system is temporarily destroying the process containing the activity to save space.

The system may also call this method when an orientation change occurs, and then immediately call onCreate() to recreate the process in the new orientation.

 Activity State and Ejection from Memory

Instead the system kills an activity directly; it kills the process in which the activity runs, destroying not only the activity but also everything else running in the process, as well. Basically, when it needs to free up the RAM, the system will kill process. Moreover, a user can also kill a process by using the Application Manager under Settings to kill the corresponding app.

Table 1 shows the correlation among process state, activity state, and likelihood of the system’s killing

Likelihood of being killed Process state Activity state
Least Foreground (having or about to get focus) Created
Started
Resumed
More Background (lost focus) Paused
Most Background (not visible) Stopped
Empty Destroyed