Gulp JS Crash Course to Setup in VSCode to Minify & Compile SASS in Node Express & Browser JS
Jan 9, 2025
Buy the full source code of application here:
Show More Show Less View Video Transcript
0:00
uh hello guys welcome to this gulp crash course inside vs code and I will
0:06
actually show you what is gulp how why we use it inside our development gulp is
0:12
basically guys you may say it's a special library inside uh the
0:17
programming the world where you want to basically if you want to Minify your
0:22
JavaScript or compile the SAS into CSS or if you want to compress your code or
0:30
all these repetitive tasks that you want to perform inside your development Jour Journey can be handled by a library
0:35
called as gulp so there are very various Alternatives
0:41
also there grunt as well but I will be talking about gulp in this tutorial so you will see this is actually a project
0:47
that I have right here if you see we have this index. HTML file which is present inside this folder and now if I
0:56
run this gulp script which is run by simply this command npx G LP this is
1:02
actually the command right here which I'm writing right here so as you as I execute this command guys you will see
1:09
my CSS and the JavaScript will be minified concatenated and it will be created automatically you can see that
1:16
this is the style. men. CSS you can see the CSS is successfully white space is
1:21
removed and it is successfully minified and it it has been converted from SAS
1:27
and this is actually the JavaScript also being Mini ified compressed and you can see it is appearing on a single line
1:33
This improves the performance of your app so that's why we Minify the code
1:39
when we apply for production so inside this index. HTML we are applying this style do. CSS so style scripts. min.js
1:47
so if I try to open this file in the browser it will look something like this so the heading which is appearing in
1:54
green color so if I make any sort of changes so now there is this is the biggest region
2:00
why we use gulp you can see that as I make changes it will hot reload this is
2:06
my SAS file and it is actually being compiled to CSS by S by gulp this is if
2:12
I make any sort of change right here if I want to change this color from green to Let's suppose I pick a different
2:25
color so if I change this to this color so you will basically see again the
2:30
script will run automatically so when we make changes
2:35
automatically this script will run and now you can see that color of the text if you see the color of the text is
2:41
successfully changed and uh you can make any changes it you can see you can
2:47
change let's suppose if you want to add a style phone size if I make it larger
2:54
45 pixel so again it will run automatically hot reload and now my text
2:59
size have been increased so this is actually a SAS file if you see this is not a CSS file this is actually a SAS
3:07
file which has converted to CSS you can see that automatically so this is
3:12
actually a setup that you need to do guys in this tutorial I will show you the step bystep setup how to set up gulp
3:18
inside vs code and how to use it inside your JavaScript project and I will also show you how to integrate this inside
3:25
Express app as well in nodejs if you want if you are developing a nodejs Express backend API if you want to use
3:31
it how you can use it uh this is actually we using multiple SAS files so
3:36
this is you can see buttons s this is actually a button color if I change this
3:42
color let's suppose to any color so again this will run you can see
3:48
that and now if I open my style. CSS you will see the button color is whichever
3:54
color put I put right here it is there and if I show you the styles. main.css
4:00
this is actually the button color you can see button style is also there so we have multiple SAS files if you see in
4:07
different folders and we are actually concatenating both these SAS files into a single styles. min. CSS file so this
4:14
is actually the features of gulp it can be used to compress the size of SAS
4:20
files it can be compiled SAS to CSS JavaScript Minify it you can even reduce
4:26
the size of your images as well so if you're using images so if you know gulp has various plugins which is actually
4:33
allows you to uh do these task so in
4:38
gulp we basically assign some task so we have a specialized gulp file if you see
4:44
inside of a root project we have this gulpfile.js inside this file we assign
4:49
different task related to this is actually the task which will actually clean the CSS this is a task which is
4:56
assigned to clean the JavaScript this task will compile the SAS to CSS and this will Minify the CSS this will
5:02
Minify the JavaScript this will actually watch for any changes that you make inside your application this gulp script
5:09
will once again run these task so by default this task will when we run this
5:15
command if you simply run this command npx gulp this is when you run this
5:21
command uh this executes this line executes line number 60 so by default
5:29
this will run and it will run all these task that we have defined right here if you see so it will actually Define all
5:36
these task the ordering is important so whichever task is actually mentioned first will be executed first and then we
5:43
will execute the rest of the task so at last if you see it has it is watching
5:48
for the changes if you make any sort of change it will reexecute so coming back
5:54
to the JavaScript you will see actually we have this s simple console lock statements High called second statement
6:01
and if you see our minified JavaScript you can see everything is there on a single line at is compressed and if I
6:08
show you the inspect element you will basically see all these statements are appearing in the browser let's suppose
6:15
if I make any sort of change I add a alert statement right
6:24
here so you will basically see it will hot re reload you will see that
6:30
so now let's get started guys how to implement or configure gulp inside the
6:36
project so I will actually close this and start from scratch so I will here in
6:43
my projects directory I will simply make a new directory I will call this as G
6:49
project 2 and open it inside vs code so you will basically see we are actually starting
6:56
it from scratch let me just navigate to the folder
7:01
so you can see we are starting it from scratch nothing is present so first of all we do need to define the
7:08
package.json file by npm inate Dy this will create the package.json file then
7:13
we need to install the gulp dependency and uh as a Dev dependency so
7:20
just add this flag npmi gulp G lp--
7:26
save-dev so simply execute this command and it will install this dependency as a
7:31
Dev dependency and then we do need to install some plugins which actually gulp
7:38
third party plugins which allows you to carry out these functionalities of compiling SAS to CSS or minifying the
7:44
code or concatenating different files into a single file so for that we have
7:49
different plugins out there and you can even go to the gulp official documentation and there you will see the
7:56
plug-in section you can actually explore multiple plugins so you can see almost
8:03
4,325 plugins are there so one such plugin is gulp SAS which actually
8:08
compiles your SAS to CSS so you can see 348,000 weekly downloads so we will
8:14
install this so npmi GP SAS and one such plugin is for
8:20
concatenating GP concat and also in the same way we do
8:27
have a plugin to actually clean the wh space g lp- clean and also we have to if
8:35
you want to compress or Minify your files we have gulp ugly FY ugli fi this
8:43
is a basically a plug-in which will Minify all your files this will be for cleaning the white space which is
8:50
present in the files this is for concatenating or joining or merging multiple files this is for compiling the
8:57
SAS to CSS so these are four different plugins out there so simply sorry we
9:02
need to just add D- Sev so it will be installed as a Dev
9:08
dependency so these are different plugins out there so once installed it will be mentioned inside so we are using
9:15
the latest version of gulp which is 5.0.0 and my nodejs version is also the
9:22
latest one if if I just show you so my nodejs version is 20.9 point0 so you can
9:29
just just cross check your node version and gulp version as well so at the time of recording this video we are using the
9:35
latest version so now let's get started for the very first thing we need to Define is the gulp file so whenever you
9:42
are working with gulp you need to Define this file gulpfile.js so the icon will also change
9:50
in vs code if you see it will recognize that it's a gulp file and here you will actually Define the configuration code
9:57
for your gulp task so right in this file first of all
10:05
we do need to require the gulp package right at the very
10:10
top and then we also need to import the SAS which is a Gul uh plugin for
10:19
actually compiling the SAS into CSS and here also guys one other dependency I
10:25
forgot to tell you we do need to require the
10:30
SAS package s a s so simply install this package as well npmi D- sa Dev SAS
10:39
Library this is required if you want to compile your SAS into CSS so that's all
10:45
we do need to require it as well right here just write here require
10:52
SAS so after this we also need to import the buil-in path module as well of
10:58
nodejs and let me just import all these dependencies clean CSS so I think we
11:05
haven't installed this so gulp clean CSS is actually required to actually create
11:11
the white space which is present inside the CSS file so gulp clean CSS this is
11:19
actually the plugin gulp clean CSS so also install this also so once installed
11:25
we can import this gulp scle CSS and also we need to import the ugly file plugin of gulp gulp ugly
11:35
file and then we also need to import the concat plugin which is used to
11:40
concatenate multiple files G concat and then we also need to
11:46
import the gulp clean plugin so this is required for all other files such as
11:51
JavaScript if you want to clear the white space this is just a configuration
11:57
code guys once I written this code I will show you how it works and how so
12:03
just need to write as I'm writing so now we need to actually configure the paths of the
12:09
files so before configuring this you need to create a disc folder so this
12:14
disc folder we will actually be having our production files so here I will Define my index for HTML so here you can
12:22
write your HTML code whatever you need to basically let me just say gulp basic
12:28
example so here uh what I will do I will have this link tack which will
12:35
be having redirect we will be including the style. min. CSS which will be compiled by gulp
12:43
similarly we will have the script tag and it will be coming from the script.
12:50
min.js so for those we need to create the folders just create a CSS folder and
12:56
the JavaScript folder so the folder will be empty by default so gulp will
13:03
actually run the task and all these minified CSS and minified JavaScript will be automatically be compiled and
13:09
stored inside these folders and then we will run the file so here in the HTML we can actually Define a
13:16
heading hello world and let me that's solve and then we will simply have a
13:22
button we will simply say
13:27
uh I I will say click me this is all that is there in the HTML
13:34
very simple HTML document you can open it so now nothing works because we
13:39
haven't configured the gulp right now we have just defined our production files
13:45
and here we need to define the source directory guys where you will be actually be storing your C SAS files and
13:52
the Javascript file we will be writing so just create a folder of
13:57
SAS will just create
14:03
suppose just first of all create a file just random file let's create the folder
14:09
for SAS and then the second folder for JavaScript now I can delete that
14:16
file so here in the JavaScript we will simply be saying script.js and in the
14:22
SAS we will be defining style. SAS so here we can actually be defining our
14:29
simple JavaScript whatever you want to do this JavaScript will be compiled by
14:38
gulp so here we can have some bunch of allert statements let me bind
14:52
a event handler to the button
15:04
so you can see we have defined an ID here let me just uh see if we are defined so just give it an ID here to
15:11
the button that's all so in the JavaScript we are
15:17
targeting the button by its ID and actually defining alert when we click the button that's all this is our
15:24
JavaScript coming back to the SAS file so in the SAS file we can basically Define some SAS so we can actually have
15:31
a variable right here of uh primary color and we can Define this
15:40
variable to be so variables are defined by not this symbol this symbol you can
15:46
define a actually a color right
15:52
here and then in the body we can use this color background color
16:01
that's all and uh you can Define phone size to
16:07
be 15 sorry 45 pixel and here we can actually be
16:14
targeting The Heading and just align this heading in the center position that's all for now these are the Styles
16:19
which we have defined in the SAS file if you see you can even have a complex SAS file depends upon you this is I'm just
16:26
an example that I'm showing you this is the s file this is now the Javascript file now coming back to the gulp file
16:33
here we need to Define all the paths for the gulp to actually run so
16:38
here you'll Define this array it will actually contains four properties this will not be an array this will be an
16:44
object the first property will be in this object will be the SAS file so
16:50
where is it is located so it is located in the source directory do/ source and
16:56
it is present in the SAS directory
17:01
and here this is actually a wild card guys so this simply means that all the files which are present in subd
17:08
directories so this folder can can have let me call this I call this as s a s so
17:18
it can have as many subdirectories as possible so this wild card is is
17:23
basically saying that it can have subd directories as well so star star and
17:28
then we only need to Target the files which actually end with SAS files that's
17:34
all this is put a comma and then the actual location where it needs to
17:40
compile so we need to actually compile it to this disc folder and the CSS
17:45
that's all the file name will automatically be taken care of so let's
17:50
suppose if the input file is style. SAS then uh automatically gulp will actually
17:57
output style. main. CSS so we don't need to
18:03
write the output file name in the in the uh destination it will automatically
18:09
taken care of similarly for the JavaScript it will actually be saying it
18:15
is located in the source directory in the JavaScript folder and we use the
18:22
same pattern right here and the destination where you need to save it we need to save it in the disc folder in
18:27
the JavaScript folder folder that's all again we are not providing the file name it will automatically taken care by gulp
18:34
that's all uh for the paths now we need to Define some task so basically task in
18:42
gulp is generally what to do so they are simp simple lines of code
18:49
which actually defines what to do so we can define a task in G by using the task method and here you need to give the
18:55
name of the task you can Define any name of your choice so the first task I will Define is to clean the CSS clean the
19:02
white space which is present in the CSS so this actually will use the method
19:09
gulp do source so what here we need to provide the location of the file so it is located in the path. joint here we
19:17
using the object here paths.
19:22
CSS like this so we are actually taking the this object we have have basically
19:29
saying that uh where you need to save this file you need to save this
19:34
file in this location so we are actually targeting this and
19:41
then here we need to provide the so all the files which are ending
19:47
with CSS so clean CSS actually means guys we are actually deleting the
19:52
previous file so that we can compile the new ones so that's meant by Clean not the white space we are actually deleting
19:59
the files then we actually need to pass an object as in the second parameter this
20:06
object takes two properties which is allow empty to be
20:11
true and read to be false we are not reading the file we are simply deleting it so that's why we need to put false
20:19
right here and then we have a pipe function
20:24
inside gulp we can use this pipe function and here we can use the plugin which is clean so this will actually
20:30
delete the previous file you define this we are coming it using gulp do clean plugin we are actually deleting that
20:37
file so clean. CSS so this we can do this for the same
20:44
thing for the JavaScript as well so what I can do we can simply repeat this for
20:50
the JavaScript so here we can Define the task clean JS and this will be paths or
20:57
JS this will will be for the JS that's
21:02
all the logic will remain the same but here now we are doing it a new task for the JavaScript for deleting the previous
21:09
JavaScript files that's fine and now the task here will be for
21:16
compiling SAS to
21:23
CSS sorry CSS so now we will simply say gulp
21:29
task and he can simply say
21:34
SAS and we can define a call back function so this task will actually compile the SAS to CSS and right here
21:42
we'll be providing the path of the file so it is present inside paths. SAS file
21:48
so inside this we need to use the pipe function as I already told you let me show you step by step
21:59
do pipe so here using a SAS plugin and it
22:04
actually contains some events so if any sort of error take place we can simply
22:10
Define it like this log it log error so if any error take place we can Define it
22:16
in the console if no error take place then we need to save this file at the destination so gulp do destination this
22:23
is the actual function which saves the file at that particular location so we have the location fast. CSS that's all
22:31
this is really simple guys we provide the input location output location and if any sort of error take place we log
22:36
the error in the console now we can actually run this task by Simply Having the default task gulp task we can Define
22:44
it default task like this so This runs basically a series of tasks we can
22:52
Define multiple task as well but for now we will only be running the SAS task as only so what it will do guys it will
22:59
actually compile this SAS code that is written inside style. SAS and it will create a new directory a new file in the
23:06
S CSS folder just you need to now execute this command npx gulp so if you execute this
23:15
command you will see on the left hand side it will compile the SAS into
23:23
CSS and now you can see that so it is starting the fall task that we defined
23:29
and then it is running this task SAS and it takes really small time and now you
23:36
can see the SAS has been converted to CSS all the styles that we
23:44
defined and if you check your file uh you will
23:52
see okay let me just move it in the index for let me
23:59
okay
24:05
CSS style dot CSS sorry style. CSS sorry this
24:12
creat style. CSS not style. min. CSS if you see that now the Styles have been
24:18
successfully applied so we can actually make any change in our SAS file let me choose a different color you will
24:26
see for this it will not automatically reload we need to actually run it for
24:31
run it again so again it will change you'll see the color will change to Green so this is not very good every
24:38
time we make a change we need to execute this command so for that we have a task
24:43
that we can Define in our Gul file so this task actually watches for the changes that you make similar to any
24:51
node modon that you have say so we can actually assign a task of watching the
24:56
changes like this and then then we have this call back function which actually watches for any changes that the user
25:03
makes to the any file so right here you can simply say watch for changes which
25:08
are happening in the S SAS file and then run this task run this
25:16
task which is SAS that's all so what this code does guys you will see you
25:21
have defined a watch task and it is watches for everything which is happening in this SAS file and then we
25:28
need to run this task once again so if you now execute this for the very you
25:34
need to now execute only once so you can see finished default okay we now need to do just add
25:42
this so whenever you define a new task we need to add this in the default task we adding it in the default task so if
25:50
you now run so if you now see now I can't
25:55
actually execute any other command so it is watching for the changes so now if I
26:01
make any sort of changes now the color is green if I try to actually change
26:07
this color to so you can see that automatically
26:13
it's it changes whenever we make changes it automatically runs this s TX you will
26:20
see that so this is really important thing guys we don't need to do
26:25
repetitive task again and again that's why use gulp in the background so you can actually use this command and run it
26:33
in the background while you are developing your projects locally this is really useful dependency it is not used
26:40
for production but it is only used for uh local environment when you developing your project it makes the things really
26:46
easy and now I will show you how you can do this thing for the JavaScript as
26:53
well so we can if you see the
26:59
style. CSS that we got it actually contains white space we we also need to
27:05
Minify this as well we only need to have little space you all so if you want to
27:12
Minify this there is a plugin that we can use so we defined this task right
27:19
here uh I think uh for minifying the thing we do
27:24
need to define a task for this so we can actually Define a task for minifying the
27:30
spaces wi space Minify CSS so inside this function what this
27:37
does it actually returns a function gulp source and here we need to define the
27:43
path. join past. CSS here we are actually targeting the style. CSS file
27:51
which is actually compiled from SAS now we need to actually remove the white
27:56
space so for removing the white space we can actually use the pipe operator and here we can actually use the plug-in
28:03
clean CSS that we imported so it will clean the white space which is there in the output file and we need to create it
28:10
in a new file so we need to use the concat plugin as well and here we'll be defining a new file which will be
28:17
created in the same folder by the name of
28:22
styles. main.css
28:30
it will be created in the same folder and then we need to Simply say gulp do
28:37
destination paths. CSS that's all so now this task guys it is f five
28:46
four lines of code in the first line we are providing the input file which is style. CSS which gets compiled from SAS
28:52
and then we actually remove the white Space by using this plugin clean CSS and then we concatenate
28:58
everything in a single file called as styles. min. CSS this file and then we
29:05
are simply saving it so if you now need to actually assign this we can after
29:11
compiling it we can simply assign the task Minify
29:16
CSS like this so if you now run this once
29:22
again so if you see now your style. CSS will have spaces but it has now created
29:28
a new file which is styles. min. CSS and it doesn't create it doesn't uh have
29:34
spaces it is all happening in the single line all the white space have been removed and minified and this also saves
29:42
a lot of time and efficiency because in production level applications you need
29:47
to have minification of your code so if you now check the code will remain
29:55
constant but if you check the view page source this is your style do okay we are not
30:02
loading the styles. main.css we just need to change it we need to load the
30:08
styles. min. CSS file so if you make this change the code
30:15
will remain the same but now if you check view page source so you can see that all your code is actually
30:23
minified so you can see that and we can also make any change right
30:31
here if I change this to Let's suppose so again it will run
30:37
automatically and uh uh I think this is not
30:46
running okay yeah this one uh whenever the file is changed here also you need
30:52
to add the task as well so whenever the file is changed we need to compile it
30:57
and then we need to also Minify it as well so Minify CSS so just add this task
31:03
once again right here as well so if you now
31:09
refresh and if I try to change this
31:19
color let me run this once again if you make lot of changes you need to restart
31:24
your gulp command so just make sure sure now if I change this uh let's suppose
31:30
this background color to now it automatically changes so you
31:36
can see that guys we can even change the color of the text let's suppose to
31:43
White so you can see that so now we will actually be doing the same thing for the JavaScript as well you can see the
31:50
JavaScript is not executing because we haven't done that so in the gulp file we
31:55
need we need to define the jav JavaScript as well
32:01
now for the JavaScript we just need to Minify it so we will Define the same
32:07
task for the JavaScript as well which is Minify
32:13
JS so here we can actually Define the same things gulp do
32:19
Source paths. JS source and
32:25
then for actually minifying the JavaScript we do have a plug-in which we installed it earlier which is called as
32:31
ugly file ugly file will actually compress or Minify the JavaScript code
32:37
and then we need to Simply use the concat filter or Plugin to actually
32:43
store all this in a single file scripts. min.js and then we also need to save
32:49
this location so gulp do destination pass. JS destination that's all
32:59
the spelling of minifi is m i n i fi sorry minifi JS so we have defined this
33:06
everything now we do need to add this to
33:12
the right here in the watch filter and also in the default filter as
33:21
well Minify GS and here also
33:30
Minify
33:35
JS so if you refresh your application for this you need to restart
33:50
this if you see in the JS folder this script is created scripts. min.js and it
33:56
is actually all the code in the JavaScript has been compressed and it is appearing on a single line you will see
34:03
that so in the index.html we are actually loading this uh sorry this
34:08
needs to be scripts just make sure and now you can see your alert statement is all working
34:14
properly if I click the button click me you will see Hello World so all the code
34:20
guys you'll see it is working the console log statements is also working so you can make any change now in the
34:27
jav JavaScript as well let's suppose you just need you don't need to open the dis folder simply open the development
34:33
folder in the source folder you can modify the SAS you can modify the JavaScript and gulp will automatically
34:40
run in the background and it will make sure that your all the changes have been taken place so you can see that
34:49
automatically hot reload functionality is there open your JavaScript if you want to remove this alert statement and
34:55
let's suppose if I want to change the test this is go this is John
35:05
from so now if you just need to refresh
35:13
it okay if you see uh the previous JavaScript is if I change the JavaScript
35:20
it is not working this is because guys we haven't added the clean JS and the clean CSS if you see we
35:29
have in the starting of the video we actually added these two task which is clean CSS and the clean JavaScript so
35:36
this is actually used if you want to clean JavaScript if you want to make changes if you in the JavaScript it
35:43
should reflect that's why we also need to at the very top we can assign this clean
35:50
CSS and clean JavaScript so this will automatically be
35:55
running because if you you make any sort of changes in CSS and JavaScript it will automatically delete the previous files
36:03
and then it will create new files with the new newly changes that you have made just add this and similarly add this as
36:12
well right here as well whenever you make changes these two
36:17
tasks will be running first of all it will delete the previous files and just create new
36:23
ones so for that you need to refresh your gulp npx
36:32
sculp so it is saying that clean GS path argument must be of type
36:39
string okay I think let me see
36:50
clean PA
36:55
thought okay just need to be paths. JS destination sorry just make
37:03
sure and this is this will be uh star
37:08
min. so we are targeting the minified file so we need to delete the minified file so that's why all the files
37:15
starting from min.js and I think we do need to do it for the CSS as
37:22
well yeah I think for the CSS okay okay
37:28
for the CSS it's correct but for the JavaScript it was creating
37:35
problem so run the gulp file and now if you see you will see this alert
37:41
statement this is John and now if I show you if I make
37:47
changes in the JavaScript as well just don't open the this folder
37:53
just if I make changes
37:58
so it will now
38:13
execute uh I think uh I made some typ of mistake right
38:24
here if I change the JavaScript right here
38:31
here and also for the SAS if I show you basically if I make a another file let's
38:37
suppose a button file in SAS you can have multiple files as well if you know we can actually have
38:44
various styles for our different components so you have a button component right here we can actually
38:49
Define a button color let's suppose to be
38:56
FFF and then we can actually have a button selector we can change the background color of the button to
39:04
be like this and now we can actually import this in the base CSS file so we
39:10
can use a statement called as
39:17
import sorry add theate symbol for the import we need to import the button
39:23
Style so if you do this now it will also
39:31
compile this as well so once you do this if you see the dis folder now it in the CSS folder
39:39
it has actually created a button folder automatically and inside the button folder we have the button. CSS so this
39:46
is actually the styles for the button but now in the minifi file if you see you get actually concatenate each and
39:54
everything in a single file so if you see the output file the button
40:02
color so we actually targeted the button color
40:09
which is actually this color which is I think it's a white color so I need to
40:14
change this color let's suppose
40:29
uh button color
40:34
uh to the same color let's
40:44
suppose so as I make this change you will see in the Styles or mins or css it will the button color is changed so now
40:52
you can see that we can have different components gulp will automatically do this for us you can add multiple
40:59
components in SAS as well and similarly in the JavaScript as well you can
41:06
actually add some more JavaScript ad and then it will compile it in a single file
41:12
single Javascript file script. main do this is actual crash course guys about
41:17
gulp you can actually explore more about gulp by visiting their website and
41:24
documentation it's a very good tool and it has a lot of plugins available for carrying out the small little task and
41:32
if you want to integrate this inside a express application as well you can just
41:37
have a index.js file just create the basic Express server if you do need to
41:45
integrate that just create a new Express app start this app on P 5000 and just
41:53
you need to load the file
42:03
server is lisening on Port
42:08
5,000 then we can make this directory static directory as
42:15
static that's all so we just need to install the Express package so now just
42:21
open a new terminal so just install npm Express so
42:27
it will install the Express package so you can now run the
42:33
application nodeb index.js it will start this application on port number 5,000 you can directly open it Local
42:41
Host 5000 so the same thing will also happen
42:46
in the nodejs express app as well you can see that so again if you make any sort of
42:55
changes inside your
43:05
SAS if you change the background color automatically it will run you'll see
43:11
that in both the scenarios the if you're running it in a browser or in in a
43:18
Express environment in a back end both the environments will work with gulp so this is the actual crash CES guys of
43:25
gulp how to actually do
43:30
the these things so thank you very much guys for watching this video and uh I
43:36
will be seeing you in the next please hit that like button subscribe the channel as well
#Development Tools
