So welcome to building Web applications with Go the intermediate level, and this course is not intended
for absolute beginners, as the subtitle intermediate level might suggest.
I do assume that you have a working knowledge of HTML and a basic understanding of the go programming
language and how to work with databases and things like that.
And if you don't have that skill set yet, this course isn't for you.
I recommend you take an introductory course first.
There are many to choose from on Udemy and I have one up and you can have a look at that if you wish,
but assuming you have that basic skill set.
Let's talk about the kinds of things we're going to cover in this course.
So we'll be looking at how to build multiple applications from a single code base.
I want to talk about multiple applications.
I'm talking about the front end, the back end micro services, things like that.
So we'll have a single git repository of code.
And from that single repository will produce multiple applications.
One will be the front end.
And of course, that's what the user sees in a Web browser.
One will be the back end, which is an API.
We can call to fetch data to update data, things like that.
We also have one that's a micro service because Go excels with micro services.
And I thought I'd include an example micro service in this course.
We'll also be working with stripe processing, credit card transactions, refunding credit card transactions,
that sort of thing.
And we'll also look at how to purchase a monthly subscription to a service.
Now, while we're building the front and back end, there's various things you obviously need for a
modern Web application, and we'll be covering the vast majority of them.
For example, we'll have authentication both on the front end and on the back end.
So on the front end will authenticate with a username and password and we'll set some sessional variables
and keep the user logged in.
And that sort of thing will also, for the back end, be using stateful tokens for API authentication.
And there's a fair bit of work to set that up, but it's absolutely worth it.
And it ensures that you have a very secure Web application will also cover user management, how to
add, edit and delete users, how to allow users to reset their passwords if they forget them.
And as I said, we'll also be looking at micro services.
We'll build a single micro service that actually just received some information in a particular JSON
format.
Doesn't care where it comes from and it will produce a PDF version of an invoice based upon the information
it receives and send that to an end user.
So we'll email invoices to people as PDF attachments.
So let me give you a look at the kinds of things we're going to be building.
So this is a very simple website, not graphically attractive, but we're not interested in making things
graphically attractive because this is not a course in graphic design.
Instead, we're interested in functionality.
So this is a fictitious website or fictitious company that sells widgets which are actually fidget spinners
or so my daughters tell me.
But I called them widgets.
It doesn't matter.
So we have a home page and as a non authenticated user, I can come over here and say, I want to buy
one widget and here's a picture of the widget.
It costs ten dollars.
I fill out the basic information, put in a credit card number and this front end after we submit this
form or as soon as we click that charge card actually gathers the information from the form, builds
JSON request, sends it off to the back end, which is also written in go process is a credit card transaction
and sends a response back.
Very straightforward.
Now I can buy a single widget or I can buy a subscription.
So again, we're going to call strike after we get this information and we're going to charge someone
twenty dollars a month and they will get three widgets for the price of two every month.
Very straightforward.
Now, if I log in as an authenticated user admin at example, dot com with a password.
Once I log in, I have this admin menu available to me and from here, and this is the first major thing
we'll build in this course, we have a virtual terminal that allows us to simply charge a credit card.
So, for example, someone phones me, says, I'd like to pay my bill and I charge a credit card, very
straightforward.
Then we can look at all sales.
And as you can see, the data here is pagination so I can go from one page to the next.
And this is all handled on the back end where we send a request off to our back end API saying, get
me this page of data and we draw the table based on JSON response.
We have the same sort of thing for subscriptions, of course, and we finally we can manage all of our
users.
So I can edit a user, I can make changes, I can add a user and I can also delete users naturally.
Now, this all might seem pretty straightforward, but in fact we have multiple applications, including
a micro service running in the background, and we have to communicate between the front and the back
end and the micro service.
And there's a great deal we have to cover in this course in order to make this an efficient, safe and
scalable Web application.
So let's get started.