Golang, or Go, is quickly becoming one of the most popular programming languages around. Its simple syntax and the vast library of packages make it an attractive choice for app developers looking to build high-performance applications.

large_golang.jpg

medium_golang.jpg

small_golang.jpg

thumbnail_golang.jpg

golang.jpg

Making the Cut: Why Golang is Rising Above The Rest


Companies are being pushed to provide an intuitive user interface in today’s digital era instead of simply providing functionality. As a result, user-friendly online apps are in high demand.

Developers are constantly evaluating different frameworks to meet this demand and provide the best of the options. This list includes Node Js frameworks. According to Nodejs' survey study, they've become the platform of choice for [4 out of 5](https://www.toptal.com/nodejs/why-the-hell-would-i-use-node-js) back-end and comprehensive engineers.

However, because of the technology's prominence, its active developers are constantly developing new frameworks. As a result, picking the best framework from a plethora of choices becomes too complex.

This article will walk you through some of the most acceptable Node Js frameworks and developmental best practices for building dynamic web apps for your company. So, let's get started with the fundamentals.

# What exactly is a Node?

Node is a fully accessible, cross-platform runtime environment for running JavaScript code from outside the web, commonly known as Node.js. For example, a virtual server like V8 from Google runs JavaScript on the webserver to execute JavaScript on the backend servers; thus, Node is a wrapper over virtual machines like V8 with built-in components offering extensive capabilities via an easy-to-use asynchronous API.

Node is used to create backend infrastructure such as APIs (Application Programming Interfaces). These capabilities are powered by consumer applications, such as web applications on internet browsers and mobile applications on mobile platforms.

Users view and engage with these customers' applications on the surface and connect with programs running underneath the server or even in the cloud information, send an email, push alerts, start workflows, and more.

So, here's a rundown of the top NodeJS frameworks that will provide you with the most excellent assistance. First, take a look at the benefits and how easy they are to use.


## 1. Express.js

Express.js is a robust methodology that takes a minimalist approach to development. Express.js is a well-known example of a simple framework for your code design. However, using it in website development will need some basic programming abilities and knowledge of the Nodejs ecosystem.

So because Framework includes ready-to-use API connectivity, you may consider building web applications quicker using it. In addition, it is ideally suited for corporate or browser-based apps because of all the formatting, sophisticated routing security mechanisms, and debugging capabilities.

## 2. Koa.js

Koa.js is among the most popular Node.js frameworks for building various online services, often known as APIs. Creating these APIs is fun and straightforward with Koa because it has a stack-like approach for dealing with HTTP intermediaries.

It also actively legitimizes Node defects. With this architecture, you may keep several versions of the information displayed to visitors using the same URL, such as interpreting a page, customizing information in e-commerce sites, having alternative forms for pictures, and so much more.

Koa is what you need when speed is a top priority for your online application. The framework can create complex applications with large and skilled programmers, which is very useful for massive projects. Moreover, Koa has proved to be a quicker platform than Express in certain situations.

## 3. Socket.io

Socket.io is a Javascript framework that allows you to create real-time applications and enable bi-directional communication among web clients and the server.

This toolkit framework aids in the creation of apps that need WebSocket building. Applications like Whatsapp, for example, operate in the backdrop for daily coverage and continually updating the underlying process for new texts or changes.

One of the most acceptable Node.js frameworks, Socket.io, also provides real-time analytics in fewer code lines, which is why businesses like Bepro and Patreon utilize it.

It's excellent for creating real-time apps that rely on servers to transmit data without any client having to ask for it. Dashboard Interfaces, Score Tabs, Chatbots, web conferencing applications, and so on are examples.

## 4. Hapi.js

Eran Hammer launched Hapi.js at Walmart while attempting to manage crowds on Black Friday. Application programming interface (API) services, sites, and HTTP proxy apps are created using hapi.js, an open-source most refined acceptable node JS platform for building JSON API.

The well-developed module architecture and many essential features like authentication mechanism, implementation caching, config file capability, error detection, logging, and more make the Hapi among the most popular frameworks. In addition, many large-scale websites, including PayPal and Disney, create helpful apps and provide technological solutions.

## 5. Total.js

Total.js is one of these platforms that provides a CMS-like interface and everything you need from a Node.js setting. In addition, it’s a full-featured open-source framework that gives developers complete freedom.

The framework exists in a range of variants, including Eshop, CMS, and HelpDesk. With the assistance of these variations, the application will have more future potential for Internet-of-things connections, REST operation, and super-fast apps with minimal cost of maintenance and consistent service.

Total.js is a comprehensive framework that programmers may use for bespoke development, Internet of Things programming language interfaces, eCommerce online progression, cloud computing, and real-time cooperation, among many other stuff.

If you're operating on an application with a tight deadline, Total.js, for example, may help you get it done faster and save money.

## 6. Meteor.j

Meteor.j is an open-source website development platform that allows you to send data changes to your clients without requiring the assistance of your engineers. It's exceptionally responsive to various device-operating platforms, including iOS and Android for smartphones and desktop applications.

It is one of the most acceptable options if the project team is comfortable with JavaScript. It's also simple to learn and a lot of fun to write with. In no time, you'll be able to utilize it to create applications. The Framework may provide you with the same coding you would use for a web app while developing a mobile app. It's now simpler to get daily coverage on installed applications without interrupting the user's current session.

# Final Thoughts

If you choose the appropriate Node Js foundation for your web application, you'll be well on your way to developing dynamic apps. It relies entirely on your online and [mobile application development](https://reliasoftware.com/services/mobile-app-development) needs, as well as how you need them to react to customer requests. Know and understand the scope of the project and choose a structure that meets all of its requirements.

You should have a fair assumption of what you want to achieve in the end or you can hire a [NodeJS app development company](https://reliasoftware.com/services/nodejs-development). Next, study the market and determine which platforms your rivals are using to build their apps. Analyzing all of these criteria before choosing a structure from the above list is the most significant recommendation to take out of the whole article, whether you're a novice or a professional in the business.

Companies are being pushed to provide an intuitive user interface in today’s digital era instead of simply providing functionality. As a result, user-friendly online apps are in high demand.

Leading Node.Js Frameworks For Web Application 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.

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?

Making the Cut: Why Golang is Rising Above The Rest

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