
# Relia Software included in Finest 500 company for App Development by TopDevelopers.co!

## Relia Software has done it again! 
## We have made it to Finest 500 Mobile App Development companies at TopDevelopers.co.

[Relia software](https://reliasoftware.com/) is a company that puts a lot of emphasis on engineering that is driven by the user experience. At Relia Software, we think it's important to make digital experiences that reach a lot of people and provide value at every step. Since 2011, we've delivered more than 300 applications for web and mobile platforms in 10+ industries. This gives us an edge when it comes to making sure our clients get the best product possible. Relia Software's team is ecstatic to share the news that our company has been recognized by TopDevelopers.co as one of the [Top 500 Companies for Mobile App Development](https://www.topdevelopers.co/press-releases/finest-500-mobile-app-development-companies-of-november-2022). This honor reinforces our commitment to our clients, and we are grateful to our team and our customers for showing faith in us.

  

TopDevelopers.co is known for its rich, well-researched directory of most successful and finest Mobile app development companies, web and custom software developers, UI/UX designers, Digital marketing agencies, Data analytics firms, Game app developers and other IT service and solution providers. Our verified reviews help find the best partner to technically accelerate businesses. The finest 500 companies list for mobile app development includes only the top agencies that can help develop world-class applications. The list has proven to be a boon for businesses making it easy to find and [hire top app developers](https://reliasoftware.com/).

  

Our entire team is thrilled to be featured on the Finest 500 List. With over 6000 firms listed with TopDevelopers.co, it is an achievement to be named among the top 1%. If your business is looking for a new mobile app development partner, check us out today. Visit [Relia Software’s profile](https://www.topdevelopers.co/profile/relia-software) on TopDevelopers.co to understand the salient features of our company, our focus areas, service specialities, cost details etc., all in one place.


Relia software is a company that puts a lot of emphasis on engineering that is driven by the user experience. At Relia Software, we think it's important to make digital experiences that reach a lot of people and provide value at every step. Since 2011, we've delivered more than 300 applications for web and mobile platforms in 10+ industries.

thumbnail_finest-500-company-for-app-development.png

finest-500-company-for-app-development.png

Relia Software included in Finest 500 company for App Development by TopDevelopers.co!

For almost a decade, Relia Software has devoted itself to provide top-notch mobile app developmentservices to make startups and established companies the best they can be. The quality of our services means everything to us. That’s why it’s an honor to be recognized by Clutch as a [top developer in Vietnam](https://clutch.co/vn/developers/leaders-matrix).

Clutch is a ratings and reviews firm that conducts research on companies across the world to determine industry leaders. [Clutch B2B leaders](https://clutch.co/vn/top-service-providers) are selected annually based on the diversity of their portfolios, market presence, and overall quality of their work, which largely informed by reviews from past clients.

We’ve created a strong profile for ourselves on Clutch, receiving solely five-star reviews. In our most recent review, we were praised for our performance and reliability in a custom software development project for iOS and Android.

*“We are delighted to be awarded as one of the best application development companies in Asia. We have been creating compelling experiences and building groundbreaking applications for our clients and getting recognized for the same from Clutch is a feather in our crown.” –Cuong Do, Marketing & Business Development Specialist, Relia Software*



Also be sure to check out our [Manifest profile](https://themanifest.com/vn/app-development/companies#reliasoftware), where you can find us featured as one of the top 25 app development companies in Vietnam. Clutch’s other sister-site, Visual Objects, helps buyers find the right fit for their projects through visually showcasing portfolios.

Most importantly, though, we want to take this opportunity to thank our clients for investing in a partnership with us and leaving us with such positive reviews. We appreciate you and plan on continuously improving ourselves to offer the best services possible.

Interested in our services? Check us out, and [let’s talk business](https://reliasoftware.com/).

For almost a decade, Relia Software has devoted itself to provide
  top-notch mobile app development services to make startups and established
  companies the best they can be. The quality of our services means everything
  to us. That’s why it’s an honor to be recognized by Clutch as a top developer
  in Vietnam. 

Relia Software is Named a Top Developer in Asia by Clutch

If you wish to sustain and thrive in today’s cut-throat competitive scenario, you ought to have a high-performing mobile app for your businesses. At Relia software, we render path-breaking and innovative mobile app solutions to our clients and play a vital role in their digital transformation journey. We are happy to announce that in a [press release about the leading mobile app development companies](https://www.topdevelopers.co/press-releases/top-mobile-app-developers-october-2020), TopDevelopers.co has acknowledged our efforts and included us in the list of top app development service providers of the year 2020.

At [**Relia Software**](https://reliasoftware.com/), our USP is developing bespoke mobile apps and other software solutions which ensure that the end product is highly scalable and the end users have a great time using it. The mobile apps delivered by us are highly customer-centric and robust and have all the ingredients in providing an edge to our clients over their peers.

Since 2011, Relia software has been instrumental in rendering state-of-the-art for both mobile app and web platforms for companies belonging to 10 plus industries. Apart from mobile app and web development, our expert app developers and designers are competent enough in providing services in Ecommerce development, UI/UX designing, wearable app development, game development, Blockchain and many more. Our innovative work techniques and result oriented mobile apps have made a name for us as a reliable tech partner of the service seekers worldwide. And, that’s the reason why we find our name in the list of [leading app developers in Illinois](https://www.topdevelopers.co/directory/mobile-app-developers/state/illinois#relia-software) consistently.

![Relia Software adds another feather to its cap as one of the Top Mobile App Development Companies](https://res.cloudinary.com/reliasoftware/image/upload/v1608259798/mobile-app-relia_u963g4.png)

We also hold great expertise in dealing with the new-age technologies such as Artificial Intelligence (AI) and Machine Learning (ML). Creating an immersive experience with the mobile apps for the end users is one of our strengths that help in increasing the revenue of our clients.

In order to gauge the likes of the targeted audience, Relia Software first builds an MVP so that when the entire mobile app is out in the market, it could be more streamlined. In the past nine years, we have delivered our services for companies coming from different industry backgrounds such as IT, media, business services, financial and payment, utilities, healthcare and life sciences and many more. To understand more about our work over the years, please visit [our portfolio.](https://reliasoftware.com/work)

We offer great mobile app solutions for any business requirement and we believe in understanding the clients, their business, and the business trend is the foremost thing to offer the best solution. When you visit [Relia Software’s profile](https://www.topdevelopers.co/profile/relia-software) on TopDevelopers.co, you can clearly understand our focus areas, service specialties, competitive pricing details and more.

**Who is TopDevelopers.co?**

_[TopDevelopers.co](https://www.topdevelopers.co) is a widely respected directory and review platform of B2B IT service providers. They take a neutral approach in analyzing the companies. The team of analysts at TopDevelopers.co vets the companies through stringent parameters which ensure that only the most competitive firms, businesses, enterprises, and entrepreneurs are filtered through their process. This helps the service seekers in getting a ready to use pool of companies from which they can choose the appropriate firm according to their need._


If you wish to sustain and thrive in today’s cut-throat competitive scenario, you ought to have a high-performing mobile app for your businesses. At Relia software, we render path-breaking and innovative mobile app solutions to our clients and play a vital role in their digital transformation journey.

Relia Software adds another feather to its cap as one of the Top Mobile App Development Companies


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?

Relia Software included in Finest 500 company for App Development by TopDevelopers.co!

Relia Software included in Finest 500 company for App Development by TopDevelopers.co!

Relia Software has done it again!

We have made it to Finest 500 Mobile App Development companies at TopDevelopers.co.

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