We are going to eventually create several different packages to form our overall project, managing
each of these projects manually is going to be a little bit tedious.
So instead, we're going to be making use of a satellite that is going to automatically manage these
different projects for us.
Let's take a look at the Seelie and really understand what it is going to do for us.
OK, so we're going to install onto our local machine a tool called the Lernout Seelie.
This is a tool that we can use for managing a multi package project, which is exactly what you and
I are doing right now.
We are building a multi package project.
I first want to help you understand one of the things that llena is going to do for us.
So let me give you a very quick example.
Now, I do really want to highlight that this entire example I'm about to give you is just one feature
inside of or not.
It is not.
The only thing that learned does by any degree is just one feature that is very handy.
So let's imagine for a second that we are not building this entire book application.
Instead, we are building maybe some kind of printer package.
Our printer package is very simple.
All it does inside of its indexed JS file is import some kind of message package and then console that
message.
And that's pretty much it.
We're going to imagine that this message package is also developed by you and I, so we might first
decide to develop this message package.
We would first develop it on our local machine.
And maybe as a part of developing the package, all we end up doing is exporting some greeting or some
message that we want to eventually be consumed by our printer.
So maybe we end up with just something like export default, hello, or something like that.
After developing this package on our local machine, we would eventually need to publish it off to 9pm
so we might decide to publish it off.
So this will be now a copy of our message package on AMPM registry.
Now, we've got two separate copies of this package.
We would then go back over to our printer, we would do an install message, so we would add in message
to the packages on file, then 9pm on our local machine would go up to the registry and try to download
the message package.
So we would download this package and add it into the node modules directory like so.
Now, whenever we run our Prenter project, whenever we see the important message from message, that
means that we're going to go into our node modules directory, find the current message, which right
now is just hello and print it out.
That's pretty much it.
So this is life as usual.
Let's say really quick and we decide that this hello right here, it's not really the best message that
we could possibly come up with.
Maybe we decide.
Let's try a couple of different variations on this message.
Think about what we would have to do to rerun the printer package with a different message over here.
To do so, we would go to our local copy of the message package on our machine, we would change the
string inside there, change it to something like hi there.
We would then increment the version of this package and then republish it to NPM.
Now we've got two separate versions of our message package, maybe a version one.
And a version to.
If we want our Prenter package to make use of this new version of our message package, we would have
to update the version inside of our packages on file.
So go to 2.0.
We would then have to reinstall this dependency, so we would go and get this new version.
And install it into our node modules directory, and we had to do all that work just for updating this
one single string, if we wanted to change the string again and test it out instead of a printer package,
we would have to go through this entire process yet again.
So, as you can tell, that starts to get very tedious very quickly.
So here is one thing, one thing out of many that Llorona is going to do for us.
Llorona is going to make it very easy for us to consume updates between our different modules on our
local machine as we are developing them very easy.
So rather than going through this entire process of republishing to NPM and then reinstalling into node
modules, instead, Lerner is going to allow us to set up a link from our node modules directory over
to the copy of this package on our local machine.
So this will be a link to message on local machine.
So whenever our application tries to find the message package, let's say, instead of our index dogs
file, rather than finding some kind of preinstalled version of message inside of our known models directory,
we're going to automatically go over to the message on our machine and take whatever the current value
is for that message directly from that file over here so we can change this string high there as much
as we please.
We could change it to this or that or whatever else.
And for every single change, that change will immediately be reflected back over inside of our printer
project.
We do not have to go through this entire laborious cycle of a republish every single time we make a
change.
So, again, this is one feature of llena that's going to be absolutely fantastic for very much simplifying
this multi package development.
I want to repeat now for the fourth time that this is just one thing that Laura does.
We're going to use it for many other features as well.
OK, so now that we've got a better idea of what Lenina is all about, I want to give you a couple more
notes around it in just a moment.