We’re all familiar with the whole “press release” approach to marketing. It’s a tried and true method that works really well. The downside, however, is that it is fairly ineffective for building links from other sites.

We’ve all got questions for those who are in the know: How do I get my website ranked? How do I make sure my links are good? What do all those numbers mean? How can I make sure I see the traffic my website deserves? How do I know if I should buy Organic SEO or PBN (Private Blog Network)? The answer is as simple as you want it to be. However, in order for you to get the answer, you’ve got to know your market, and you’ve got to work with an expert.

I’ve been writing for as long as I can remember and I’ve always preferred the written word over video games. I got my first blog post published in 2007 and I haven’t looked back since. I created this site to share the knowledge I have gained over the years as a SEO, self-help blogger, technology enthusiast, and avid gamer. I also created this site to document my experiences in the search engine optimization industry so that I could pass it on to anyone else who wants to learn about search engine optimization.


An Android app built with Kotlin that uses the TMDB API to display the most popular, upcoming and trending movies and TV shows. It is built on the principle of pure architecture, repository model, MVVM architecture in the presentation layer and Jetpack components.

I created this repository for several reasons:

Explore approaches for implementing pure architecture and SOLID principles in an Android application.
Learn the libraries/tools supported by Google and most Android developer communities.
Experiment with modularization and dynamic function modules.
Study the implementation of the Picture-in-Picture function.
Demonstrate advanced development techniques using a modern technology stack.

To build the application, you need to modify the api key in gradle.properties. First you need to generate your own api key by creating an IMDB account and generating an api key.


Complex architectures like pure architecture can also increase code complexity, as decoupling involves creating multiple data transformations (mappers) and models, which can ultimately increase the learning curve of your code to the point where a simpler architecture like MVVM is preferable.

So let’s get started…

What is pure architecture?

A well-planned architecture is extremely important for scaling an application, and all architectures have a common goal: managing the complexity of your application. This is not a problem for small applications, but it can be very useful when working on applications with longer life cycles and a larger team.

Clean architecture was proposed in 2012 by Robert K. Martin in the Clean Code blog and follows the SOLID principle.

The circles represent the different levels of your application. Please note that :

The middle circle is the most abstract and the outer one the most concrete. This is called the principle of abstraction. According to the abstraction principle, the inner circles should contain the business logic and the outer circles should contain the implementation details.
Another principle of pure architecture is the reversal of dependencies. This rule states that each circuit can only depend on the nearest internal circuit, i.e., low-level modules do not depend on high-level modules, but vice versa.
Why pure architecture?
Free communication between codes – code can be easily changed without affecting all or much of the application’s code base.
It’s easier to test the code.
Separation of tasks – different modules have specific tasks, which makes modification and maintenance easier.
Principles of S.O.L.I.D.
Single Responsibility : Each software component should have only one reason to change – a responsibility.
Open-ended: You must be able to extend the behavior of a component without interrupting its use or changing its extension.
Replaces Liskov: If you have a class of the same type and subclasses of that class, you should be able to subclass the use of the base class without breaking the application.
Interface separation : It is better to have several small interfaces than one large one, to prevent a class from implementing methods it does not need.
Dependency Reversal: Components should depend on abstractions and not on specific implementations. In addition, higher level modules should not be dependent on lower level modules.
1. Area.

This is the basic application layer. The domain layer is independent of the other layers, so domain models and business logic can be independent of the other layers. This means that changes in other layers do not affect the domain layer, for example. For example, a change to the screen interface (presentation layer) or to the database (data layer) does not result in a change to the code in the domain layer.

Include components at the domain level :

Models : Defines the basic data structure to be used in the application.
Deposits : Interfaces used by the use cases. Implemented at the data level.
Examples of applications/interactions: They encapsulate a single action, such as retrieving data from a database or sending a message to a service. They use benchmarks to decide what action to take. They usually replace the invoke statement, so they can be called as a function.
2. Data.

The data layer is responsible for selecting the correct data source for the domain layer. It contains the implementations of the memories declared in the domain layer.

Data layer components include:


-Therefor models: Defines the POJO for network responses.

-Asset models : Defines the SQLite database schema.

Deposits : Responsible for data transfer at the domain level.
Cartographers : You convert data between domain, dto and entity models.
Network: He is responsible for the implementation of network operations such as. B. the definition of the API endpoints with the retrofit.
Cache : It is responsible for performing caching operations with Room.
Data source: Responsible for choosing the data source (network or cache) to use when retrieving data.
3. Presentation.

The presentation layer contains components that participate in the presentation of information to the user. The main components of this layer are views and ViewModels.

Technology stack.

This project uses many popular libraries, plugins and tools from the Android ecosystem.

The models.
Observer Model – An observer model is a software design pattern that defines a one-to-many dependency between objects, such that when one object changes state, all dependent objects are notified and automatically updated.
Example of a warehouse : The repository model is a software design pattern that prevents us from working directly with the application’s data and creates new layers for database operations, business logic, and the application’s user interface.
UseCase Pattern – The UseCase Pattern is a software design pattern used to bridge the gap between business and system models without changing the content of the requirements or anticipating architectural options.
Hilt – Dependency injection library.
Android KTX – Provides concise and idiomatic Kotlin for Jetpack and the Android platform API.
AndroidX is a significant improvement over the original Android support library, which is no longer supported.
Life Cycle – Perform actions in response to a change in the life cycle status of another component, for example. B. Actions and fragments.
LiveData is lifecycle aware, meaning that it respects the lifecycle of other application components, such as actions, extracts or services.
ViewModel – Designed to store and manage lifecycle data related to the user interface. The ViewModel class allows data to survive configuration changes, for example. B. Rotate the screen.
Data binding – allows you to bind UI components in layouts to data sources in your application using a declarative format, rather than programmatically.
Room – Provides an abstraction layer over SQLite used for offline data caching.
The Navigation component is a component that allows you to simplify the implementation of navigation, from simple button clicks to more complex models.
MotionLayout – Helps you create and manage beautiful user interface animations.
Retrofit is a type-safe
http client and supports coroutines out of the box.
GSON is a JSON parser used to parse
level queries for entities and contains
non-zero parameters – and defaults to Kotlin.
OkHttp logging interceptor – logs data from HTTP requests and responses.
Coroutines – The library supports coroutines.
Streams – Streams are built on coroutines and can provide multiple values. Conceptually, a stream is a data stream that can be computed asynchronously.
Timeline to facilitate logging.
Material Design – for stunningly beautiful user interfaces.
Glide images library- to load images from the database and store them in memory.
kotlinx.coroutines- library to support coroutines, provides the coroutines runBlocking constructor used in testing.
Truth – Assertion library, provides readability over assertions.
MockWebServer is a web server for testing HTTP clients that validates requests and responses from the TMDB API with a retrofit client.
GitHub Actions – GitHub actions are used in this project to check syntax correctness with KtLint, run unit tests, and create a new package if errors are made on the main branch.
KtLint – The project uses KtLint to check the correctness of the syntax.

In this section I have listed some of the sources, i.e. articles and GitHub repositories, that I used to create the :

Robert K. Martin’s Pure Code blog.
Detailed guide to android app development with pure architecture model medium article.
Clean architecture component Boilerplater Repo GitHub.
Force GitHub repo by David Odari demonstrating the use of
Clean architecture tutorial for android article by Raywenderlich that is really beginner friendly.
Article on pure architecture in android on Medium.
Introduction to application architecture and Introduction to application modularization – Article from ProAndroidDev.
Other useful resources.

In this section, I’ve included resources that are not purely architecture related, but have been very helpful for learning other Android components and tools:

Pokedex GitHub repo by Ronnie Otieno demonstrating how to use various Jetpack components.
The basis of the test on the official android developers website.
Android MotionLayout Tutorial – Retractable View – A blog post on how to create a retractable view with MotionLayout.
MotionLayout Blog – Collapsible Toolbar shows how to create a collapsible toolbar with MotionLayout
Introduction to Github actions for Android Mindorks blog on customizing GitHub actions for Android projects.

Here you can find screenshots of the application:



 This article is going to be about the smart link building strategy that every SEO must be following and implementing it in their indexing strategies. This is a little bit different than regular link building as this is all about how we find and build links that are positioned as “Smart Links”.. Read more about link building strategies 2021 and let us know what you think.

Related Tags:

link building strategies 2020types of link building strategiescreative link building strategieswhat is link building seolink building strategies 2021link building strategies list,People also search for,Privacy settings,How Search works,link building strategies 2020,types of link building strategies,creative link building strategies,what is link building seo,link building strategies 2021,link building strategies list,link building techniques,link building examples