1
00:00:00,910 --> 00:00:05,320
I know I've said this many times, but our application is looking pretty good at this point, and I

2
00:00:05,320 --> 00:00:09,340
really mean at this time, I think that we've done just about everything we need to do really on the

3
00:00:09,550 --> 00:00:14,320
back side of things, at least when it comes to managing, creating and modifying individual components.

4
00:00:14,710 --> 00:00:19,060
So moving forward, we're going to start to change gears just a little bit and think about how a user

5
00:00:19,060 --> 00:00:23,470
is going to actually launch our tool on their local machine and some other considerations around that

6
00:00:23,470 --> 00:00:23,940
as well.

7
00:00:24,790 --> 00:00:29,080
So let's first begin by taking a look at a couple of diagrams and understanding the next couple of things

8
00:00:29,080 --> 00:00:30,100
that we're going to be working on.

9
00:00:31,130 --> 00:00:36,440
OK, here's the next requirement I want to set up for our application at present, whenever a user starts

10
00:00:36,440 --> 00:00:41,690
to add in some cells or modify any cells, all that information is lost as soon as they refresh their

11
00:00:41,690 --> 00:00:42,150
browser.

12
00:00:42,710 --> 00:00:43,690
I don't want that to happen.

13
00:00:43,700 --> 00:00:45,800
I want the user to be able to persist their code.

14
00:00:46,470 --> 00:00:50,990
So we're going to add in some functionality to our application to allow a user to modify, create,

15
00:00:50,990 --> 00:00:52,250
delete or whatever.

16
00:00:52,280 --> 00:00:56,330
Some number of cells as a user starts to modify all these different cells.

17
00:00:56,570 --> 00:00:58,430
We're going to take all that information.

18
00:00:58,430 --> 00:01:01,070
So all the raw code, all the raw text, all that stuff.

19
00:01:01,340 --> 00:01:06,020
And we're going to somehow persist, all that information into a file on the user's hard drive.

20
00:01:07,270 --> 00:01:11,380
So all the information for one notebook will be stored inside of one single file.

21
00:01:12,300 --> 00:01:16,860
Now, I want to really very quickly tell you why we are going to save all this information to one file,

22
00:01:16,860 --> 00:01:20,670
we could, of course, figure out some other way of saving information about stem cells.

23
00:01:20,980 --> 00:01:25,500
For example, we can make use of that local foraged library to just save information about all these

24
00:01:25,500 --> 00:01:27,670
cells directly into the user's browser.

25
00:01:28,200 --> 00:01:31,150
We could just take all these cells and store them in local storage.

26
00:01:31,200 --> 00:01:35,480
There's a wide variety of different ways we could persist this information inside the browser, but

27
00:01:35,490 --> 00:01:40,780
instead want to specifically persist all these different cells into a single file.

28
00:01:40,950 --> 00:01:45,180
The reason for this is that I eventually want to make it really easy for a user to share these files

29
00:01:45,180 --> 00:01:46,170
with other users.

30
00:01:46,710 --> 00:01:51,210
A user should also be able to open up these files that have all the information from these cells and

31
00:01:51,210 --> 00:01:53,710
be able to read them like a normal JavaScript file.

32
00:01:54,330 --> 00:01:59,190
So the whole goal here is to make sure that a user can walk away with some file that works independently

33
00:01:59,190 --> 00:02:01,270
of our entire book application.

34
00:02:01,440 --> 00:02:02,550
That's the real goal here.

35
00:02:02,820 --> 00:02:08,789
I want the user to just be able to very easily share the file, commit it to get make backups of it,

36
00:02:08,970 --> 00:02:12,000
manually modify it inside of a code editor, anything like that.

37
00:02:12,360 --> 00:02:16,830
And that's all going to be much easier if we allow a user to save information about these cells into

38
00:02:16,830 --> 00:02:20,610
a file compared to storing information about all the cells inside of local storage.

39
00:02:22,780 --> 00:02:27,070
Next up, I want to think a little bit about how we're going to eventually allow a user to make use

40
00:02:27,070 --> 00:02:27,820
of our application.

41
00:02:28,090 --> 00:02:29,720
Are they going to eventually launch it?

42
00:02:30,130 --> 00:02:34,840
Well, you might recall that when I gave you a demo way long ago at the very start, of course, I showed

43
00:02:34,840 --> 00:02:37,020
running a command like this to start up the application.

44
00:02:37,030 --> 00:02:39,730
It was something like Northparkes JDBC serve.

45
00:02:40,630 --> 00:02:44,660
And then we printed up a message that said something like, open up your browser, navigate to localist

46
00:02:44,680 --> 00:02:45,730
four thousand five.

47
00:02:46,360 --> 00:02:50,920
So I want the user to build a run, a command like this, to launch the application and then be able

48
00:02:50,920 --> 00:02:55,540
to, of course, just go to local four thousand five and see the app appear in the browser.

49
00:02:56,650 --> 00:03:00,230
So those are two immediate requirements that I want to start to think about, how are we going to allow

50
00:03:00,230 --> 00:03:05,620
a user to launch the application and how is the user going to persist information about these cells

51
00:03:05,620 --> 00:03:06,730
onto their local machine?

52
00:03:07,210 --> 00:03:12,250
These two items might not seem very related, but it turns out they very much are very closely related.

53
00:03:12,970 --> 00:03:13,940
Let's take a pause right here.

54
00:03:13,990 --> 00:03:17,680
We're going to break down these two big requirements and understand how to implement them in just a

55
00:03:17,680 --> 00:03:18,060
moment.