So I had a lot of fun putting this course together, and I hope you found some useful content in here,
and I just want to take this last lecture to point you to a few resources that you might want to investigate
as time goes on.
So, for example, our micro service, if you think about what happens every time we call our micro
service, it works this way.
We actually take some information we already have and go format.
We convert it into effectively a text file in the form of JSON.
We send that off to the remote service or micro service, which then captures that text file, which
is Jason translates it back into something go canoe's and then it moves on and does something.
So there's that whole middle part where we're taking data that's already in a go format, converting
into text, then converting it back and then doing the work that's required.
Well, that's actually kind of inefficient.
And there is a protocol known as our P C that actually addresses this problem.
And I'm not going to go through it in detail, but I will post the link to go to the course resources
for this lecture.
And you can have a look at and there are examples for go for C++, for Java, for Python and for others.
So that's one thing you might want to look at.
The other thing to bear in mind is that our micro servers, for example, it actually fires off go routines
that send email.
And it's entirely possible that we could shut down that application for maintenance or whatever while
it's in the process of constructing in about to send an email so that email never gets sent.
And that's bad.
So one thing you might want to look into are signals, signals and traps.
And the ones you really want to pay attention to are ones like Sigge Term where software is terminated.
It sent a chill on Linux and there's an equivalent thing on Windows, of course.
Well, you can actually trap for those.
And I'll post a link to this page as well as to this page, which is a blog post that goes through how
you can shut down worker go routines gracefully.
In other words, keep the program running until all of the existing routines complete, whatever task
they have to complete and then terminate the program.
And it's relatively straightforward, but it's something you might want to look into.
Almost certainly have a follow up to this course at some point in the future where we go through these
and other things.
But in the interim, if you have some spare time, you might want to give these things a look.
All right.
Happy coding.