The ever-evolving mobile world has consistently surprised all of us with its cutting-edge capabilities and advancements. What began as a simple concept has now become an integral part of our lives, allowing us to experience stadium-like atmospheres in our own homes, create homes that are run with a few simple commands, and so much more.

Curious to know what the future of mobile app development holds? Here, we will explore the expected changes and advancements in mobile technology, as well as how they will impact our lifestyles. It's important to stay up-to-date with the latest trends and developments, so that we can take full advantage of the benefits they offer. As the mobile world continues to evolve, it's essential to keep up with the constant changes.

Now, the mobile application domain is experiencing rapid changes, with its wing getting more with every passing day. It’s not that the world is seeing the rise of one trend, it’s in big numbers which are different from one another. Various attributes of the mobile world are connecting with the audience and will surely help you with excellent facilities.

With lots of innovation and inventions lying under the belt, we are here to help you acknowledge the future of mobile application development in different aspects. Yes, below mentioned are a few of the attributes where the world is looking with lots of expectations because of their success in initial stages. With high expectations, we are here to help you understand what can help you the most in the next time, let’s dive in:

The Internet of Things (IoT), Artificial Intelligence (AI), and Mobile Cloud Computing are going to revolutionize the way the world looks and works.

AI will assist us in interacting with machines and providing us with the best of assistance in various domains. Finally, mobile cloud computing will allow us to store and access large amounts of data without having to worry about security and space. These revolutionary technologies are sure to drastically change the world in the coming years.


The mobile world has never failed to surprise us with its attributes and evolution. Right from its initial stages to now, we have seen everything we had in our mind, and now we can imagine more from it.

large_colorful-3D-elements-5g-technology-technology-presentation.jpg

medium_colorful-3D-elements-5g-technology-technology-presentation.jpg

small_colorful-3D-elements-5g-technology-technology-presentation.jpg

thumbnail_colorful-3D-elements-5g-technology-technology-presentation.jpg

colorful-3D-elements-5g-technology-technology-presentation.jpg

The Future of Mobile App Development & Why You Focus on It

For business owners, developing an app for their company may seem to be a great idea. Understanding the differences between hybrid and native applications is the first step in determining which app would benefit the company. This particularly holds in the modern era when apps are practically ubiquitous and digital marketing is the primary method of promotion.

## The Year 2021 - A Developer's Dream

Applications have risen in popularity over the last decade or two, and almost every consumer on the planet now utilizes them on their mobile device. This is something that company owners should take full advantage of.

Creating an app is a no-brainer for e-commerce companies or service providers. However, online shops, counseling services, language instructors, and just about every other company that can improve efficiency by providing a mobile app to its customers should seriously consider doing so.

It's time to employ a developer if you can conceive of a use case for a business app that can offer something tangibly valuable to your customers while also increasing conversions.

Even if you engage an app developer to create your business app, you'll need to determine whether you want to build it natively, hybrid-style, or a web app. So before getting started on the project, it's good to grasp the essential distinctions between applications.

The following are the critical differences between hybrid and native applications.

## What Does a Native Application Mean?

A native application is software or a program designed to accomplish a specific job in a given environment or platform. Software development tools (SDK) create native applications for a particular framework of software, hardware platform, or operating system.

Android apps are created using the Java Development Kit on the Java platform. In contrast, iOS apps are created with the iOS SDK, Swift, and Objective C. Similarly, the Windows platform necessitates the use of.NET.

## What are the advantages of using a native application?

-   They tend to function better offline, which means they don't need internet access to run (for the most part.) If a user is stranded in the middle of nowhere, such as on a plane or the subway, they may still utilize the fundamental functions of your program.

-   In [native mobile app development](https://reliasoftware.com/services/mobile-app-development), programmers use various programming languages to create special codes for different operating systems. Because the software is tailored to a single operating system, it runs well.

-   With native SDKs, you can access device capabilities without dealing with the complexities of native plugins, and future device features will be accessible right out of the box.
    
-   Because native apps are a refined version of the operating system's default programs, they have a familiar appearance and feel. This comfort may enhance the overall user experience.
    
## Why not choose a native app?

-   Different skill sets are needed to build, maintain, and administer the same program on each platform, increasing the application’s cost.
  
-   Each platform code will have its release cycle and upgrades, adding to the time and expense of development.
   
-   It will be more expensive since the app will need more developers to create and maintain a code base for each platform.
    
-   When compared to hybrid applications, there is less flexibility.
    
## What is the definition of a hybrid application?

Hybrid applications are native apps solely because users may download them from the platform's app store. It has access to all of the platform's native features. It has the potential to function similarly to a native app.

CSS, HTML5, and JavaScript are the most common languages used in hybrid app development. It's just a web app embedded in a native app shell and linked to the device's hardware.


## Why should you go for the hybrid application?

-   Because all that is needed is web technology, the same development team can create an app for any platform, including a website.
    
-   If you have a limited budget, hybrid app development is the ideal option. You don't need to employ several programmers to work on different OS systems.
    
-   A hybrid app may provide the exact and consistent user experience across platforms, even if the user switches between devices or browsers.
    
-   Hybrid application creation and maintenance (including updates and modifications) is quicker since developers have to build one codebase.
    
## Why not choose the Hybrid option?

-   [Hybrid mobile applications](https://reliasoftware.com/services/mobile-app-development) depend on plugins to access the device's built-in functionality due to their design.
    
-   Due to the nature of hybrid applications, the app's look may differ from user to user. This depends on the software version they're running and the operating system they're utilizing. To prevent this, extensive testing will be required.
    
-   Hybrid applications put a layer between the source code and the target platform, which is most likely the hybrid mobile framework. This may mean a drop in performance.
    
-   Hybrid apps rely on various libraries and frameworks, including Cordova and Ionic, which must be updated with platform version updates and releases.
    
## To put it simply

The primary distinction between hybrid and native applications is that hybrid apps are created for many platforms. In contrast, native apps are designed for a single operating system. So it’s the difference between having a separate app for each smartphone operating system and having a consistent application across all platforms.

## The Final Decision

Finally, the division is based on your company's objectives and priorities. However, if you just have a few months to build the app, it is suggested that you utilize a native app. That's because you want to concentrate all of your efforts and resources on providing a singularly excellent experience for a single user base.

If you fail, you'll have to iterate fast, and upgrading code for various platforms adds to the effort. On the other hand, if you want to test your app's user-friendliness in a small private market, it may be worth creating it as a native app.

​Once the testing process is complete and the features have been tested and specified, switching to hybrid to expand to additional platforms may be a good idea. However, the business would save a lot of money by not investing in hybrid development if the app didn't work out during the testing phase.

​If you need an application that provides the most excellent possible user experience, security, and performance, go with native development for your business's app. When it comes down to it, developing a native app is a safer option since it encourages you to concentrate on the bare minimum of features rather than huge feature sets. In addition, it is better to accomplish one thing very well than many things poorly.

For business owners, developing an app for their company may seem to be a great idea. Understanding the differences between hybrid and native applications is the first step in determining which app would benefit the company.

The Real Difference Between Native and Hybrid App Development


The real estate industry is one of the most rapidly changing markets in the world. As technology advances, so too does the way we buy, sell, and manage properties. As a result, digital technology is having a major impact on the real estate industry.

  

Like any other industry, the real estate sector also has a variety of operational activities and processes that can be optimized and transformed with digital technology with the goal to improve productivity and profitability. In fact, we can already see a change in the behaviour of real estate agents, sellers and occupants (owners or tenants), who are today more open to embracing digital technology through the value chain. Enabling this transformation is the deluge of data that is now being gathered and harnessed right from construction and purchase to real estate management. All that data is helping agents sell better with deep customer insights, helping customers do extensive research and make the right decision, and improving the overall living experience. There is a marked improvement in the quality of services and processes.

What’s evident is that the key driving factors behind digital transformation are a good buyer experience, efficient processes and compliance with regulations. The buyer experience especially is a key factor be it commercial or residential, because buyers want a seamless experience right from property discovery to post-sales maintenance. There is also a demand for transparency, accountability and honesty in all operations and business dealings such as contracts, paperwork, etc due to the size of financial transactions. In fact, the volume and size of finances involved and from the safety perspective, the real estate industry is always under the close watch of government agencies making compliance a big concern. Enter digital technology that can alleviate all these concerns.

Let us look at the top ways in which digital technology can transform the real estate industry.

#1 Search and buy

According to [research](https://www.nar.realtor/sites/default/files/reports/2017/2017-real-estate-in-a-digital-age-03-10-2017.pdf), by the year 2017, more than 51% of real estate buyers were using the Internet to research and make a real estate purchase (commercial or residential) decision. Today, if any real estate agent or firm worth its salt ignores online websites and listings, they are sure to miss the gravy train. It’s not a new concept at all. Any business needs to be present and sell where customers are looking, and today’s buyer is all about digital tech. If the real estate agent/firm has its own website then it is worth the effort to invest in digital marketing tactics like SEO, online advertising, etc.

One way that digital technology is transforming the real estate industry is by making it easier to buy and sell properties. Through the use of apps and [websites](https://reliasoftware.com/services/web-app-development), buyers and sellers can easily search, compare, and purchase properties. This makes the process of house-hunting much more efficient and streamlined, allowing buyers to find the perfect home quickly and easily.

  

![](https://lh5.googleusercontent.com/KKBMzBU-LJtreyPMD24Vs9tXwJmxwWMViCwh5XIo6UiWCOaXvlpGeKzVLdK51hPDOCujqj_pfNYxw_2T7GFFWqICbT0aCBBPXvJ4cyHwcfiwjn5grMjydpCD5aYIL4EmVsjy-V07Uf8bLCbqV54ANjrlWHSjs8Hey1WYPZfFeHSzo98U_vrKRi2hY1bc8g)

#2 Real estate agent 2.0

So here’s a fact. With so many property listings and websites easily available now, it is very easy for buyers and sellers to connect directly and eliminate the middleman, i.e. the real estate agent. Even Whatsapp has become a popular way of sharing property details and finding buyers. But the good news is that agents are not completely out of the picture. Not if they see these new channels as opportunities to increase their market reach by leveraging digital marketing and offering customized services by using analytics to understand buyer needs.

Another way that digital technology is revolutionizing the real estate industry is by making it easier to access and manage rental properties. Landlords are now able to use apps to advertise their rental properties, collect rent, and even screen potential tenants. This eliminates the need for costly middlemen and makes managing rental properties much simpler.

  

#3 Changing site visits

There is a two-pronged approach to how digital tech will change site visits. The first is the operational aspects where agents can use websites or custom software to schedule site visits and also plan pre-visit requirements like a deposit, online forms, valid ID proofs, financial references, etc. The second aspect is a more radical change, where virtual and augmented reality apps can provide a 360-degree experience of the site online from anywhere and without the need to ask the buyer to travel or spend time scheduling a meeting. Imagine being able to view a property by moving around a property virtually and experiencing the size and placement of rooms, sizes of windows, even the fixtures like wardrobes and closets, or being able to step into the bathroom and get a feel of the shower area. Advanced VR software even allows buyers to virtually check out the neighbourhood. It’s like going to the site without even stepping out of your home or the agent’s office. Think Pokemon Go!

#4 Digital documentation

Preparing documentation related to the rental or purchase of any property, commercial or residential, used to take hours. The documents were prone to manual errors, and in cases where the purchased property was in another city or country, there would also be the hassle of including regional laws and regulations. But today there are several websites and automated tools available that take a fraction of the time needed earlier to prepare all documentation. If engaged early during the transaction, these portals record and manage each step right from documents needed for the first visit pre-requisites to transaction-related documents, payment information, ongoing rental revisions, etc. Such portals also allow direct validation credentials with government authorities, enable digital verification of documents, and help with other legal requirements. For the buyer, this means transparent pricing and taxation, transparent and legal payments and the elimination of fraudulent transactions.

#5 Easy Loans Management

Digital technology is also making it easier to finance real estate purchases. There are now a variety of online lenders that offer competitive rates and terms for home loans. This makes it easier for buyers to secure financing and purchase their dream homes.

  

#6 Estate management

Even the way properties are designed, built and then managed can be transformed. In fact, there is already a prevalence of the Internet of Things, or IoT, in several countries. One such example is smart sensors that leverage data to guide and help manage buildings of all kinds. In New York, realtors, agents, and owners are using smart sensors and [mobile apps](https://reliasoftware.com/services/mobile-app-development) to monitor commercial and residential complexes in real time and that too remotely. These sensors share continuous data on the condition of equipment, service interruptions, security scenario and even something as specific as building temperature. Scheduling repairs, controlling fire breakouts, and reducing the wastage of resources like water and electricity have been made so much easier by IoT adoption.

Finally, digital technology is making it easier to manage and maintain properties. Homeowners can now use apps to monitor and control a variety of systems, such as security, lighting, and heating. This makes it easier to keep track of property maintenance and keep homes in top condition.

  

#7 Building intelligence – yes, it exists!

While we’re on the topic of how technology is transforming tasks that were until now completely manually intensive, let’s also consider Business Information Modeling or BIM, which means managing the entire lifecycle of a building using digital technology. BIM is an intelligent 3D model-based system used primarily by construction, architecture and engineering professionals to understand the tools they need to plan, design, construct, and manage properties. It helps manage design phases and keep track of operations. This includes everything from the design and construction of a building to the optimization of a building’s use of space and/or occupation and the related equipment.

#8 Analytics for Insights

Real estate investors have already been using artificial intelligence (AI) powered data insights to help with their decision-making. AI is giving them insights into market trends, identifying new opportunities, charting out realistic revenue and growth plans, and even highlighting possible loan defaulters where applicable. In addition to BIM and estate management, as talked about earlier, AI-powered insights are helping real estate investors control expenses, increase investment returns and reduce risk.

#9 Digital Image Classification

Imagine selecting and posting photos, keying in details and managing listings of hundreds of properties manually. Sounds overwhelming, doesn’t it? Thankfully, real estate agents can now use digital image classification to automate photo selection by using machine learning to categorize site photos and even tag them within seconds. They can now easily sort images based on multiple characteristics like room type or number, special features, design styles, location, fittings, date required and so on. By combining this tool with their marketing software, agents can run more targeted emailing campaigns and location-specific ads.

Having said all this, the question remains how truly ready is the real estate industry for a digital transformation. In our opinion, the level of adoption and maturity vary across the world, with the [US taking the](https://www2.deloitte.com/us/en/pages/real-estate/articles/commercial-real-estate-industry-outlook.html) lead in the adoption of digital technology for real estate transformation. There’s no doubt that the industry has several challenges to reach digital transformation faster and catch up with other industries. The market is ripe with available technology and innovations that can manage multiple nuances of the industry and create lasting experiences for sellers and buyers alike. Leading firms are already started taking a bite-sized and phased approach to using technology as a business enabler and to improve customer experiences and operations. For the laggards, our message is to shape up or ship out.

Overall, it's clear that digital technology is having a major impact on the real estate industry. According to a recent survey, 85% of real estate professionals believe that digital technology has had a positive impact on their business. Furthermore, 91% of real estate professionals believe that technology will continue to play an important role in the industry in the future. Clearly, digital technology is here to stay and will continue to shape the real estate industry for years to come.

  

Have any questions about real estate [app development](https://reliasoftware.com/) and its cost? Feel free to talk to us.


Take a look at how digital technology is having a major impact on the real estate industry in 2023

large_rel-eatste.jpg

medium_rel-eatste.jpg

small_rel-eatste.jpg

thumbnail_rel-eatste.jpg

rel-eatste.jpg

How Digital Technology Is Changing The Real Estate Industry in 2023

A web developer is a professional who works on websites, domains, and apps. They plan, modify, write code, and build web pages, internet sites, and apps.

[Web development](https://reliasoftware.com/services/web-app-development) is a rapidly evolving field. There is no justification for procrastinating as a programmer. If you want to remain on top of the latest trends and maintain a competitive edge, you must continuously study and develop your abilities.

If you're like most programmers, you've undoubtedly glanced at the code and thought about how you might improve it.

There will always be opportunities for growth as a programmer, no issue what you're doing in your profession. Learners should improve their abilities, while experienced developers should constantly try to enhance their code's clarity, efficiency, and ease of maintenance.

This article offers fifteen ideas to assist developers in enhancing their development abilities and making quantifiable improvements from where they are momentary to where they want to be someday.

## 1. Make use of the proper tools

This should be self-evident: Make sure you have the suitable instruments and understand how to utilize them.

Photoshop and Illustrator are very certainly required for web designers. However, if you're a web developer, you'll need a solid collection of web development applications to assist you.

Naturally, toolkits vary across vocations and individuals. For example, some people will just require a terminal to create their websites rather than the Coda website development package. What is important is that your instruments assist you in completing the task as quickly as possible.

## 2. Participate in Open-Source Initiatives

Participating in open-source initiatives on sites like GitHub allows you to get your hands dirty with code. You may build your version of an existing project by forking it. You may also support a current site by assisting it in reaching its completion stage or by resolving small issues to enhance its reliability.

Whatever choice you pick will undoubtedly lead to minormore excellent knowledge of your code and exposure to other people's work, which may teach you a new approach.

## 3. Do what you want to do.

If your initial few moves toward career coding are tedious and uncomfortable, you're already on your way to burnout before you've even started!

To prevent this, focus on areas of growth that interest you and inspire you during the day. These are the items that will get you through unavoidable low points when you question, "Is this truly what I would like?" For most individuals, these emotions of uncertainty are inevitable. However, the more positive you have to dwell on, the greater your chances of success with growth.

You'll also enhance the growth abilities that are important to you, which is the foundation of satisfaction.

## 4. Blog subscriptions

Another talent you'll need is the ability to understand other online professionals' publications. Nevertheless, instead of taking everything stated, make choices about what seems essential and what doesn't. How-to articles are standard on blogs, and they explain how to produce, design, or edit particular materials.

Web designers should utilize websites' associated blogs to gather as much data as feasible. If you have your site, you can use hyperlinks to evaluate the writers of certain pieces and assist others in finding them as well.

## 5. Always be curious.

You can't be a competent web developer unless you have at least a passing interest in the subject. So it’s crucial in the coming years: excitement will motivate you to keep going and prevent monotony.

Now, if you want to be a computer programmer because it's simple or because you just want to earn good money, you're going to hit a brick wall. Web creation is not simple, and you'll need more incentive than simply money to get started.

Throughout your web development career, you will undoubtedly experience highs and lows in your drive. Of course, you will despise it at points. Interest, on the other hand, always returns. If not, don't be scared to try something different. The world is brimming with possibilities.

## 6. Sprints are a reliable way to work.

Practicing in sprints may help you get more done in less time. For example, write an essay in small bursts, two or three headings at a period, then have a lengthy break from it to concentrate on something else, returning later in the day.

Focusing in 10- to 20-minute increments enables your brain to create fresh thoughts while also preventing them from being overworked. In addition, focusing on a subject in small spurts ensures that you are constantly fresh when you return.

## 7. Educate individuals on what you have learned

You may believe you're not cut out for writing about code. You aren't a writer, after all. However, establishing a blog and sharing your expertise with others is a fantastic method to keep learning.

You will begin to arrange your ideas and construct the subject you write about by publishing what you understand. In certain instances, you may wish to do additional study on the subject, which will lead to more significant learning and more profound knowledge of the issue you're attempting to address.

Not just that, but blogging raises your profile and establishes you as an authority on the subject. So go forward and include a blog on your site.

## 8. Every day, code.

This is a must-have for any talent you want to improve. If you'd like to improve at anything, you must make it a regular ritual – a routine that you don't break. You will profit from this dedication in two ways.

First and foremost, as they say, "good things take time." Every one of those hours of work piles up quickly, and before you realize it, you'll have a tool belt full of projects, expertise, and languages. This is a crucial experience for honing your skills and landing interesting employment.

Second, and maybe more importantly, daily development will leave you feeling like a programmer. You'll soon stop viewing yourself as a "wannabe" and start seeing yourself as the genuine thing. This will increase your self-assurance and drive.

## 9. Have a portfolio of your work

This is where you can show off all of your work, including the websites you've built, animations you've produced, and images you've generated using your website development abilities.

Customers generally want to go through the practical content you created before entrusting their job to you. The portfolio also aids in understanding where you began, your errors, and your accomplishments.

## 10. Always have an open mind.

Congratulations if you enjoy web development and would want to learn more about it. You're a curiousexciting web developer.

Curiosity and fascination go hand in hand. Curiosity is a decent indicator of whether or not you're keen enough to program all day.

Please remember, though, that developers are not always engaged and inquisitive.

You have the essential characteristics a web developer should have: interest and enthusiasm. This is the basis you'll need to be a healthy and content web developer.

## 11. Make an effort to learn a new skill.

Test out a new language or a different method to break the monotony of focusing on numerous projects.

So, although going through with a lesson here and there won't get you to expertise, it still uses the principles of regularly being introduced to and engaged in programming.

Remember that experts created the lessons on these sites by years of expertise in many instances, and they often emphasize innovative apps in new technologies, languages, and APIs.

## 12. Get some books to read.

Even if you work in technology, grabbing up a book has a lot of benefits.

A book's size and detail enable the author to go into more depth than can be obtained on Free online courses, in an essay, or a YouTube video. Almost every coding book has something to teach you, no issue what degree of programmer you are. And, if you're self-taught, there's no better way to learn than via practice and mentoring.

## 13. Participate in groups and forums

There are numerous computer programmer groups and forums where individuals may ask questions about various subjects on the Internet. Naturally, any suggestion is generally met with enthusiasm by web developers.

Closed and open communities are the two kinds of forums. In a private forum, you must apply to be a participant and get common resources. In an open forum, anybody, both a member and a visitor, may see subjects and conversations of interest.

## 14. Don't Plan Too Much

You shouldn't design your workday any more structured than it needs to be; your intellect needs some freedom, as well as time to relax and think ultimately. So please ensure that your timetable is flexible.

While it is good to code every day, it is also essential to plan frequent breaks. As counterintuitive as it may seem, time spent doing nothing really makes you more productive.

## 15. Learn from seasoned programmers.

Finally, every novice, up-and-coming, or developing coder should search for a seasoned programmer to advise them. Developers make some of the most excellent and most eager instructors because they've spent so long learning from everyone else.

## Last Thoughts

Before you hurry to put the recommendations above into practice, please remember that modern languages and technology change over time. So while learning as many languages as feasible is a beautiful idea, you'll be a much better programmer if you focus on learning and understanding the basics of programming.

The plain truth is that the fundamentals never alter; thus, it is best to understand the underlying structure rather than the most recent major update to appear in a specific language. Understanding your preferred language, or even learning a new language, will become much simpler if you have a solid understanding of the basics.

A web developer is a professional who works on websites, domains, and apps. They plan, modify, write code, and build web pages, internet sites, and apps.

small_15-web-development-tips-to-enhance-your-skills.jpeg

thumbnail_15-web-development-tips-to-enhance-your-skills.jpeg

15-web-development-tips-to-enhance-your-skills.jpeg

15 Web Development Tips To Enhance Your Skills


### Introduction
We will learn about *SOLID principles* with a property that is very effective and understand why it is so important for unit testing during the process of working with Golang - That is **Dependency Inversion Principle**.
### When we do not comply The Dependency Inversion
>*high-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions.*

This is a definition of The **dependency Inversion** written by [ Bob](https://twitter.com/unclebobmartin),We will rely on it to understand better. First, we all know about the abstraction property in OOP, We will use concepts to uncover the necessary behavior and the hidden details of how to implement them. Second, we need to understand what are the distinctions between **high-level** and **low-level** modules?

In the Go context, **high-level** modules refer to software components that are utilized on top of the application, such as presentation code. Understanding it as a layer that provides real business value to our application.On the other hand,the majority of **low-level** software components are little code fragments that support the **higher-level** software.They keep technical information regarding various infrastructure integrations hidden.

For example ,This may be a struct that contains the logic for retrieving data from a database, sending a SQS message, retrieving a value from Redis, or submitting an HTTP request to an external API. So what happens if we break The Dependency Inversion Principle and our **high-level** component is reliant on a single **low-level** component? Let's consider the following example:

```
// infrastructure layer

type UserRepository struct {
	db *gorm.DB
}

func NewUserRepository(db *gorm.DB) *UserRepository {
	return &UserRepository{
		db: db,
	}
}

func (r *UserRepository) GetByID(id uint) (*domain.User, error) {
	user := domain.User{}
	err := r.db.Where("id = ?", id).First(&user).Error
	if err != nil {
		return nil, err
	}
	
	return &user, nil
}

// domain layer

type User struct {
	ID uint `gorm:"primaryKey;column:id"`
	// some fields
}

// application layer

type EmailService struct {
	repository *infrastructure.UserRepository
	// some email sender
}

func NewEmailService(repository *infrastructure.UserRepository) *EmailService {
	return &EmailService{
		repository: repository,
	}
}

func (s *EmailService) SendRegistrationEmail(userID uint) error {
	user, err := s.repository.GetByID(userID)
	if err != nil {
		return err
	}
	
	// send email
	return nil
}

```
In the above code, the **high-level** component `EmailService` is defined in the preceding code. This structure, which is part of the application layer, is in charge of delivering emails to newly enrolled clients. The idea is to have a method, `SendRegistrationEmail`,where the `User` ID is necessary. It retrieves `User` from `UserRepository` in the background, and then sends it to some `EmailSender` service to send the email.

We will ignore `EmailSender` for the time being. Let's focus on `UserRepository`. This structure is part of the infrastructure layer and illustrates how the repository connects with the database. So it seems that the **high-level** component, `EmailService`, depends on the **low-level** component, `UserRepository`.Actually, we will not be able to initialize the structure if we do not have a database connection.Going against a pattern like this has an immediate impact on unit testing in Go, as shown in the following code:

```
import (
"testing"
	// some dependencies
	"github.com/DATA-DOG/go-sqlmock"
	"github.com/stretchr/testify/assert"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

func TestEmailService_SendRegistrationEmail(t *testing.T) {
	db, mock, err := sqlmock.New()
	assert.NoError(t, err)
	dialector := mysql.New(mysql.Config{
		DSN: "dummy",
		DriverName: "mysql",
		Conn: db,
	})

	finalDB, err := gorm.Open(dialector, &gorm.Config{})
	repository := infrastructure.NewUserRepository(finalDB)
	service := NewEmailService(repository)
	//
	// a lot of code to define mocked SQL queries
	//
	// and then actual test
}

```
In Go, we can not just mock whatever we want. Mocking relies on the use of interfaces, which we can declare a mocked implementation for, but we can not do the same with structs. So we can not mock `UserRepository`, because it is a struct. In this situation, we will need to develop a lower layer simulation, and we may utilize the [SQLMock](https://github.com/DATA-DOG/go-sqlmock) package for the [Gorm](https://gorm.io/index.html) connection.However, it is still not reliable or effective method for testing. We must simulate a large number of SQL queries and comprehend the database schema. We must modify the unit test whenever the database is changed.

On the other side, we will have a bigger difficulty with unit testing.What happens if we switch to a different storage system, such as [Cassandra](https://cassandra.apache.org/_/index.html) ? Specifically, do we intend to have dispersed storage for our customers in the future?If this happens, and we utilize this implementation with 'UserRepository,' there will be a lot of refactor code.

We have now seen that it means for a **high-level** component to rely on a **low-level** component. But what about abstractions based on details? Take a look at the code below:

```
// domain layer

type User struct {
	ID uint `gorm:"primaryKey;column:id"`
	// some fields
}

type UserRepository interface {
	GetByID(id uint) (*User, error)
}

```
We should start by developing some interfaces definition with high and **low-level** components. In this case, we may define `UserRepository` as a domain layer interface. So, it gives an opportunity to detach `EmailService` from the database, but still incomplete. Let's take a look at the `User` struct. It provides a definition for mapping to the database.Even though the struct is already in the domain class, the infrastructure details are still its responsibility. We still break The Dependency Inversion with the new `UserRepository` (abstraction) interface, which is dependent on the `User` struct with database schema (details).That interface will undoubtedly change if the database schema is changed. The `User` struct will remain useable, but the modifications made at the **low-level** will be preserved.

We gain nothing out of this refactoring in the end, we are still incorrect. With several consequences:

1. We can not correctly test our business or application logic.

2. Any change to the database engine or table structure affects our highest levels.

3. We can not easily switch to a different type of storage.

4. Our model is strongly coupled to storage.

5. ...

### Ways to respect The Dependency Inversion

>***high-level** modules should not depend on **low-level** modules. ***Both should depend on abstractions***.Abstractions should not depend on details. ***Details should depend on abstractions***.*

Based on the sentences in bold, we will need to build an abstraction(an interface) that both our `EmailService` and `UserRepository` components will rely on. Furthermore, no method(e.g Gorm) should be used in such abstraction.Let's take a look at the code below:

```
// infrastructure layer

type UserGorm struct {
	// some fields
}

func (g UserGorm) ToUser() *domain.User {
	return &domain.User{
		// some fields
	}
}

type UserDatabaseRepository struct {
	db *gorm.DB
}

var _ domain.UserRepository = &UserDatabaseRepository{}

/*
type UserRedisRepository struct {

}

type UserCassandraRepository struct {

}
*/

func NewUserDatabaseRepository(db *gorm.DB) UserRepository {
	return &UserDatabaseRepository{
		db: db,
	}
}

func (r *UserDatabaseRepository) GetByID(id uint) (*domain.User, error) {
	user := UserGorm{}
	err := r.db.Where("id = ?", id).First(&user).Error
	if err != nil {
		return nil, err
	}
	
	return user.ToUser(), nil
}

// domain layer

type User struct {
	// some fields
}

type UserRepository interface {
	GetByID(id uint) (*User, error)
}

// application layer

type EmailService struct {
	repository domain.UserRepository
	// some email sender
}

func NewEmailService(repository domain.UserRepository) *EmailService {
	return &EmailService{
		repository: repository,
	}
}

func (s *EmailService) SendRegistrationEmail(userID uint) error {
	user, err := s.repository.GetByID(userID)
	if err != nil {
	return err
	}

	// send email
	return nil
}
```

With the new structure of the code, we can see the `UserRepository` interface as a dependency on the `User` struct, and both are in the domain layer. We now use `UserGorm` instead of the `User` struct, which no longer mirrors the database schema. The infrastructure layer lies on top of that layer. it has a `ToUser` function that corresponds to the `User` struct. We use `UserGorm` as a usage detail inside `UserDatabaseRepository` , as the actual implementation for `UserRepository`. Only the `UserRepository` interface and the `User` object, both of which are in the domain, are used inside the domain and application classes. We may specify as many `UserRepository` implementations as we like in the infrastructure. `UserFileRepository` or `UserCassandraRepository` are two options. The **high-level** component (`EmailService`) depends on the abstraction - it contains a field with type `UserRepository`. However, how does the **low-level** component depends on the abstraction ?

In [Go](https://reliasoftware.com/services/golang-web-development/), structs automatically implement interfaces. That implies we may add a check using a [blank identifier](https://yourbasic.org/golang/underscore/) instead of adding code where `UserDatabaseRepository` explicitly implements `UserRepository`. With this approach, we can control dependencies more easily. Interfaces are dependent on structure, and we may build alternative implementations and include them anytime we want to witness global dependence changes.This is a popular method in any frame work, and it is called [The Dependency Injection pattern](https://en.wikipedia.org/wiki/Dependency_injection). There are various libraries in Go, such as from [Facebook](https://github.com/facebookarchive/inject),[Wire](https://github.com/google/wire), hoặc [Dingo](https://github.com/i-love-flamingo/dingo). Let's see how it is used in unit testing :

```
import (
	"errors"
	"testing"
)

type GetByIDFunc func(id uint) (*User, error)
func (f GetByIDFunc) GetByID(id uint) (*User, error) {
	return f(id)
}

func TestEmailService_SendRegistrationEmail(t *testing.T) {
	service := NewEmailService(GetByIDFunc(func(id uint) (*User, error) {
		return nil, errors.New("error")
	}))

	//
	// and just to call the service
}

```
We may add some basic simulation, `GetByIDFunc`, as a new type that defines the method from `UserRepository` where we want to simulate, with this refactoring. This is how you build a function type in Go and give it a method to implement an interface. Our checking will be much more beautiful and efficient from now on. Whatever the situation, we may add alternative implementations for `UserRepository` and customize the check result.

### More Examples

The Dependency Inversion can be broken in other components besides struct. With a pure, independent function, for example, this is conceivable:

```
type User struct {
	// some fields
}

type UserJSON struct {
	// some fields
}

func (j UserJSON) ToUser() *User {
	return &User{
		// some fields
	}
}

func GetUser(id uint) (*User, error) {
	filename := fmt.Sprintf("user_%d.json", id)
	data, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}

	var user UserJSON
	err = json.Unmarshal(data, &user)
	if err != nil {
		return nil, err
	}

	return user.ToUser(), nil
}

```
We need to read information for a `User`. We employ files and JSON format to do this. `GetUser` reads the contents of the file and converts them into a `User` . This approach is dependent on the existence of files, and we must rely on files to verify that it is right. As a result, writing tests for this function, such as checking validation rules,is inconvenient if we subsequently add them to the `GetUser` method. The code depends on too many details, and it would be nice to create some abstractions :

```
type User struct {
	// some fields
}

type UserJSON struct {
	// some fields
}

func (j UserJSON) ToUser() *User {
	return &User{
		// some fields
	}
}

func GetUserFile(id uint) (io.Reader, error) {
	filename := fmt.Sprintf("user_%d.json", id)
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}

	return file, nil
}

func GetUserHTTP(id uint) (io.Reader, error) {
	uri := fmt.Sprintf("http://some-api.com/users/%d", id)
	resp, err := http.Get(uri)
	if err != nil {
	return nil, err
	}
	
	return resp.Body, nil
}

func GetDummyUser(userJSON UserJSON) (io.Reader, error) {
	data, err := json.Marshal(userJSON)
	if err != nil {
		return nil, err
	}

	return bytes.NewReader(data), nil
}

func GetUser(reader io.Reader) (*User, error) {
	data, err := ioutil.ReadAll(reader)
	if err != nil {
	return nil, err
	}

	var user UserJSON
	err = json.Unmarshal(data, &user)

	if err != nil {
		return nil, err
	}

	return user.ToUser(), nil
}

```
With the new implementation, we build the `GetUser` function based on the `Reader` interface. It is a component of the Go core package , [IO](https://pkg.go.dev/io). We can define various ways to provide implementation for `Reader` interface, like `GetUserFile`, `GetUserHTTP`, `GetDummyUser` (where we can use to test `GetUser' method `)

This method may be used in a variety of situations. We should strive to separate it if we have problems with unit testing or even experience with a dependency cycle in Go by giving the same interface and many implementations as we do.

### Conclusion

The Dependency Inversion Principle is the final principle of *`SOLID`*, and it represents the letter `D` in the word *`SOLID`*. It highlights the importance of **high-level** components not relying on **low-level** components. Instead, all of our components should rely on abstractions, or interface, as the case may be. Abstractions allow us to utilize our code more freely while still ensuring that it is fully tested.

We will learn about SOLID principles with a property that is very effective and understand why it is so important for unit testing during the process of working with Golang - That is Dependency Inversion Principle.

large_golang.jpg

medium_golang.jpg

small_golang.jpg

thumbnail_golang.jpg

golang.jpg

Practice of SOLID in Golang: Dependency Inversion Principle

Are you looking for an app development company which is specialized in UI/UX design, Ruby on Rails, .NET, React Native, ReactJS, NodeJS, Python and mobile app development?

The Future of Mobile App Development & Why You Focus on It

Cesc Nguyen

Developer

Read more articles

How Digital Technology Is Changing The Real Estate Industry in 2023

15 Web Development Tips To Enhance Your Skills

Practice of SOLID in Golang: Dependency Inversion Principle