from the typical applications that we're used to writing.
going to face when building those services.
So let's assume that we're writing a Java application.
it will go and save the video on the underlying file system.
that we have a record of all the videos that we've entered into our system.
that we're going to be building.
And we'll assume that there's nothing special about this.
It's just a Java application.
if we're writing this in Java is we're going to have a main method.
we could go out and spell out what those are.
you know, look for the flags that we're passing the command line.
the file that they want to add, the video.
So look for the video path and we could a whole bunch of other stuff.
But the key would be, we've got this main method, which is part of this application.
they're going to be passing commands from the command line into our application.
are being passed into our application.
they're basically sending a different command to it.
public static void main method.
passed us and then go and store something in a database or do something else.
that have it going query the information we've already stored.
Or be processed based on the information that we've already sent the application.
feedback to the user that is sending the commands to the application.
see information that comes out of the database that the user is querying.
So not only do we have a situation where we are sending commands and asking.
store data, but we also have situations where we need to based on those commands.
failure of those commands and any data associated with them.
we'll probably want to print out that query back to the command line.
helping them to figure out how to formula like that command correctly and send it.
we would expect to get some feedback telling us that the application crashed.
failure of those commands and the results of the execution of those commands.
that same host is that application.
then some application's going to be living in the Cloud.
And receiving those commands, processing data through some data store.
having to remotely send back to the mobile device the results of those commands.
to the application and results coming back that we're going to be working with.
which is the client to the application.
It's going to process that information.
And in this case, the application is going to be a server.
the mobile device, so that it can know what happened.
here is the result of running your command.
correctly or it may be sending results back saying, the server had a problem.
Here's what the problem was and it crashed.
And that's the architecture that we're going to be building through this class.
the internet to a service or server that's living in the Cloud.
the results are being sent back to the mobile client.
device to the server and communicate the results back.
that communication with the server that's remote?
How do we ensure that it's reliable?
the server can understand and process the commands for us.