I know I've said this many times, but our application is looking pretty good at this point, and I
really mean at this time, I think that we've done just about everything we need to do really on the
back side of things, at least when it comes to managing, creating and modifying individual components.
So moving forward, we're going to start to change gears just a little bit and think about how a user
is going to actually launch our tool on their local machine and some other considerations around that
as well.
So let's first begin by taking a look at a couple of diagrams and understanding the next couple of things
that we're going to be working on.
OK, here's the next requirement I want to set up for our application at present, whenever a user starts
to add in some cells or modify any cells, all that information is lost as soon as they refresh their
browser.
I don't want that to happen.
I want the user to be able to persist their code.
So we're going to add in some functionality to our application to allow a user to modify, create,
delete or whatever.
Some number of cells as a user starts to modify all these different cells.
We're going to take all that information.
So all the raw code, all the raw text, all that stuff.
And we're going to somehow persist, all that information into a file on the user's hard drive.
So all the information for one notebook will be stored inside of one single file.
Now, I want to really very quickly tell you why we are going to save all this information to one file,
we could, of course, figure out some other way of saving information about stem cells.
For example, we can make use of that local foraged library to just save information about all these
cells directly into the user's browser.
We could just take all these cells and store them in local storage.
There's a wide variety of different ways we could persist this information inside the browser, but
instead want to specifically persist all these different cells into a single file.
The reason for this is that I eventually want to make it really easy for a user to share these files
with other users.
A user should also be able to open up these files that have all the information from these cells and
be able to read them like a normal JavaScript file.
So the whole goal here is to make sure that a user can walk away with some file that works independently
of our entire book application.
That's the real goal here.
I want the user to just be able to very easily share the file, commit it to get make backups of it,
manually modify it inside of a code editor, anything like that.
And that's all going to be much easier if we allow a user to save information about these cells into
a file compared to storing information about all the cells inside of local storage.
Next up, I want to think a little bit about how we're going to eventually allow a user to make use
of our application.
Are they going to eventually launch it?
Well, you might recall that when I gave you a demo way long ago at the very start, of course, I showed
running a command like this to start up the application.
It was something like Northparkes JDBC serve.
And then we printed up a message that said something like, open up your browser, navigate to localist
four thousand five.
So I want the user to build a run, a command like this, to launch the application and then be able
to, of course, just go to local four thousand five and see the app appear in the browser.
So those are two immediate requirements that I want to start to think about, how are we going to allow
a user to launch the application and how is the user going to persist information about these cells
onto their local machine?
These two items might not seem very related, but it turns out they very much are very closely related.
Let's take a pause right here.
We're going to break down these two big requirements and understand how to implement them in just a
moment.