WEBVTT

00:00.150 --> 00:05.910
So what we'll do is first will create an hufford, Soliris, just proselytizer, designed to click on

00:05.910 --> 00:09.060
this button to get an option to either design.

00:09.070 --> 00:10.710
So we'll just click next.

00:11.340 --> 00:12.750
We'll give you creative license.

00:12.780 --> 00:21.690
We have not created any Hofreiter file previously and we'll just name it as an OK, and then we'll just

00:21.840 --> 00:22.220
finish.

00:22.230 --> 00:24.840
Now we know that four and half a we require two.

00:25.990 --> 00:32.350
They'll put boots of single bit and output should be to represent, examine, carry.

00:34.290 --> 00:36.120
And that action should be our fate.

00:37.790 --> 00:38.800
We just hit, OK?

00:40.080 --> 00:44.370
So this will automatically create a template for us where we can start writing.

00:44.640 --> 00:47.040
So we'll just go inside and have a look.

00:47.430 --> 00:51.090
OK, and then we'll just write a code for an half.

00:51.240 --> 00:56.100
And now we already know that the sum is equal to exciting between the two inputs.

00:56.100 --> 01:05.510
The sum will be equals to xor be OK and Cadi will be close to A and B..

01:05.790 --> 01:07.650
So this completes our hypothetical.

01:08.310 --> 01:14.580
OK, now what we'll do is since this is very simple circuit so we can actually proceed without performing

01:14.580 --> 01:15.740
a behavioral simulation.

01:15.990 --> 01:21.690
But when you are working with the complex system and once you complete an implementation of your subsystem,

01:21.840 --> 01:26.370
it is mandatory that you first perform a behavioral simulation and then only you proceed.

01:26.400 --> 01:32.340
So once you verify that your system is working correctly, then you proceed to building a bigger system

01:32.340 --> 01:35.400
or else you'll be finding testing and error becomes very, very difficult.

01:35.460 --> 01:41.100
OK, so what we'll do is we'll just perform the simulation once so that you won't be forgetting that

01:41.220 --> 01:46.890
in between we have to perform a simulation before proceeding to design a complex system.

01:46.920 --> 01:48.060
OK, so we'll just click on it.

01:48.060 --> 01:51.760
And simulation in fact, will not be writing test scores.

01:52.050 --> 01:58.920
OK, you can write a test that gives us more insight, but we'll use a false clock to see whether the

01:58.920 --> 02:00.460
things are working and expecting.

02:03.530 --> 02:12.410
So we'll just select input, right, click Forcillo one and zero, OK, and will choose for input the

02:12.410 --> 02:19.440
period of it nanosecond Willagee useful clock one zero and here will choose a different period.

02:19.460 --> 02:25.370
So with a single Lowville able to verify all the different combinations of the input and then we'll

02:25.370 --> 02:27.860
just proceed for an execution of a simulation.

02:28.010 --> 02:30.890
OK, now if I just try to.

02:32.540 --> 02:38.630
Verify all the food combinations, so we have an E and B Boota one, so it should be one, as you can

02:38.630 --> 02:44.040
see over here, and some issue when we have a settlement system should be one, should be zero.

02:44.090 --> 02:48.600
This is all to find when we have good zero, we have some incredible detail.

02:48.950 --> 02:52.370
And when we have one, zero sum should be equal to one and carry.

02:52.700 --> 02:57.460
So this is perfectly working with an 091 combination.

02:58.140 --> 03:04.820
Once you verify the behavior of a simple system, which you are finally utilizing to build a complex

03:04.820 --> 03:06.820
system, then you can proceed with the.

03:08.120 --> 03:14.120
Structure and say right now, what you can do is you can start writing the full article right after,

03:14.120 --> 03:20.240
and this is when we could be that you create and you will proceed with the second method.

03:20.240 --> 03:21.500
So we'll add a new source.

03:22.400 --> 03:27.180
We'll just be naming this as Fullard and we'll finish.

03:27.650 --> 03:33.050
Now, we know that for a full hour that we have a triple threat, A, B and C, which are in Push-Pull

03:33.200 --> 03:35.020
and we again have some in Korea.

03:35.040 --> 03:36.120
Is that output again?

03:37.180 --> 03:43.330
The all the polls have a series of single vote, so we'll just click, OK, now we will automatically

03:43.330 --> 03:45.640
create a template for us where we.

03:47.100 --> 03:54.420
How ABC and some care, but one difference that you'll be finding is now the half hour is our previous

03:54.420 --> 03:54.730
model.

03:54.990 --> 03:59.460
OK, and the newly created model that we wish to work on.

03:59.460 --> 04:00.800
And that's the first thing.

04:01.200 --> 04:04.800
Once you create a new source model, as you said, it stops right.

04:04.800 --> 04:07.080
Click on the folder and then set aside.

04:09.580 --> 04:14.640
So that later on, you don't need to remember whether you are working on the correct model or not,

04:14.650 --> 04:14.950
right.

04:16.010 --> 04:24.790
Now will proceed with including an hofreiter inside our court and then working around to build Fullard.

04:26.650 --> 04:34.360
So to use a half hour inside the flight, the first thing that you need to do is to include a component

04:34.630 --> 04:35.810
inside an architecture.

04:35.830 --> 04:36.080
OK.

04:36.100 --> 04:41.450
So you just go to and hofreiter, you copy from an entity that is affected and delayed.

04:41.840 --> 04:47.050
OK, so you just copied this could go to Fullagar between an architecture and a beginning.

04:47.050 --> 04:52.200
You have a space where we can declare component signals, memories, order and illuminated.

04:52.530 --> 04:57.820
OK, so we'll just start a company will paste whatever we have and we'll just do not.

04:59.170 --> 05:08.460
OK, so this once you are a company inside an architecture now you are ready to use an Hogfather inside

05:08.970 --> 05:09.500
Fullard.

05:09.750 --> 05:15.510
OK, other than this, we also need to verify whether we have all the net required for building this

05:15.510 --> 05:17.160
fully defined or not.

05:17.190 --> 05:23.700
So if you remember the circuit, we have three nights which are undefined and we plan to use a name

05:23.700 --> 05:27.090
De'Monte 23 for them and each have a series of single.

05:27.720 --> 05:34.740
So here what we'll do is we'll use a signal, OK, we have even two and three as a three.

05:35.070 --> 05:41.730
OK, and the data should be standard and the school logic because they all belong to a single bitrate

05:42.090 --> 05:45.730
and then we can in fact initialize them to see, OK.

05:47.760 --> 05:52.800
So now we have defined all the defined that also we have include a component.

05:53.370 --> 05:59.220
OK, now the next step is to find out how many instances of and how far we are using.

05:59.230 --> 06:05.700
So from the figure, you have two incidents or two components of an affair that has been utilized to

06:05.700 --> 06:07.310
below full.

06:07.980 --> 06:14.430
So we differentiate the different instances of accompanied by giving a unique name.

06:14.460 --> 06:19.500
So for this, we'll use next one as a and for this instance, we'll use it as an OK.

06:19.890 --> 06:21.180
So let us proceed.

06:21.360 --> 06:24.480
And what we'll do is we'll just bring this out.

06:25.450 --> 06:31.080
And we'll keep our schematic side by side so it becomes very easy to work on great.

06:33.420 --> 06:36.340
Now you'll be finding this is an actual instance.

06:36.360 --> 06:41.700
OK, so we set off to begin with 8H, which is the name of for instance.

06:42.860 --> 06:48.170
OK, so for this half hour that we have given information and this is how you differentiate between

06:48.170 --> 06:51.590
the different components that you use to build a complex system.

06:51.690 --> 06:57.200
OK, and he will be finding that half of it consists of four.

06:57.740 --> 07:03.260
So the name of an entity is Hafford or the name of a component is Hofreiter.

07:03.260 --> 07:04.990
So we need to use the same name.

07:05.570 --> 07:06.890
Then we need to add a.

07:10.410 --> 07:21.000
Support map signifies that we are performing the mapping of the world that we have in a pattern modeled

07:21.090 --> 07:22.080
to the doctor model.

07:22.140 --> 07:27.460
OK, so here you will be finding the first poll that we have is any B essential.

07:27.810 --> 07:34.380
So if you like to follow up auditions, for example, if you want to connect E to E, in that case,

07:34.380 --> 07:40.110
if we decided to follow up auditions, for example, my first quote from here, that is you'll be going

07:40.110 --> 07:42.060
from a left to down.

07:42.090 --> 07:49.500
OK, so first, all that you have is E then we have A B, then we have an S and then we have a C, right.

07:49.650 --> 07:51.930
So this is how our position should be followed.

07:51.960 --> 08:00.260
So first, what is the next port we have B, so we want to be part of each one to the B of Flat-Rate.

08:00.290 --> 08:06.300
Will just mentioned B here then we have some who gives us some B wish to connect to an undefined net,

08:06.300 --> 08:07.260
which is Stephen.

08:07.800 --> 08:10.070
OK, and then we have a Cadie Sukardi.

08:10.080 --> 08:11.370
We want to connect to a T..

08:12.070 --> 08:16.860
So if you following position and output, this is what we refer to as an.

08:18.690 --> 08:21.810
And implicit way of declaring.

08:22.200 --> 08:27.460
OK, so here we purely depend on production, no, again, we'll be finding we also get the warning

08:27.540 --> 08:28.290
that is.

08:30.350 --> 08:36.950
It increases the risk of design error, so it has been recommended that you go with inexplicitly, but

08:36.950 --> 08:42.620
for a simple design implicit, the implicit way of declaring A would also work fine, no problem at

08:42.620 --> 08:42.770
all.

08:42.980 --> 08:46.130
And Hoppner is very simple design so needed no need to.

08:46.400 --> 08:49.960
OK, so the next instance of and hopefully we'll just be naming it.

08:49.980 --> 08:55.130
And so this is OK again the component that we want to uses and.

08:55.850 --> 08:58.850
OK then we will be mentioning Goutman.

08:59.570 --> 09:03.100
OK, so we will be connecting to a Tevan right.

09:03.110 --> 09:07.890
So here we'll just be adding thievin then for we will be using C.

09:08.060 --> 09:08.350
Right.

09:08.660 --> 09:11.330
So for a full hour we have you see.

09:11.840 --> 09:14.060
OK then we have some.

09:14.980 --> 09:16.630
And then we have.

09:17.750 --> 09:21.830
The output of this Agatu is.

09:23.850 --> 09:27.210
So this is, again, an implicit way of declaring a.

09:27.720 --> 09:30.820
Now what explicit we meet will consider with an example.

09:30.840 --> 09:31.130
Right.

09:31.470 --> 09:38.930
And finally, you know that sea out is equal to an audio between the twenty date.

09:39.000 --> 09:45.030
So C will be equals to two or with detail.

09:46.200 --> 09:48.790
So this is how you implement a system.

09:48.810 --> 09:52.860
Now you have utilized Harper to build full right now.

09:52.890 --> 09:55.890
One thing to note, this is similar to what we did in an.

09:57.470 --> 10:03.650
Taspinar also, once we see our goal, you'll be finding that later becomes apparent model and her father

10:03.650 --> 10:06.140
becomes a daughter model, so we'll just see.

10:06.170 --> 10:06.950
It will first.

10:08.680 --> 10:11.170
This goes back to where we were, OK, we'll see.

10:11.670 --> 10:17.980
So once we see who here will be finding as we watch data and hierarchy, it will be finding now we have

10:17.980 --> 10:19.810
to have further instances.

10:19.810 --> 10:25.990
One of an instance, Niemi, another instance, new music, which are the two subcomponents, and we

10:25.990 --> 10:31.900
are merging them together to get another good point, to notice whether the circuit is correctly implemented

10:31.900 --> 10:32.290
or not.

10:32.560 --> 10:36.750
You can just go to an Arctic analysis and you can observe a schematic.

10:36.760 --> 10:44.050
So here you can clearly observe the different communication between the different components that we

10:44.050 --> 10:44.750
have inside of.

10:45.420 --> 10:48.630
OK, so this is where Artillery's has become very, very effective.

10:48.670 --> 10:55.000
So when we have a complex design began, we actually analyze the pools are going to correct.

10:56.080 --> 10:58.140
Souce and the syncopate.

11:02.170 --> 11:08.770
We'll be finding we have an Hofferman, what we'll do is we'll just keep this side by side so it becomes

11:08.770 --> 11:10.210
very easy to compare the.

11:12.170 --> 11:15.290
OK, so now you'll be observing that we have an.

11:17.090 --> 11:27.260
OK, so we have ABC, ABC, we have a seat, we have CSI, we then see is exciting between the sea of

11:27.260 --> 11:30.680
two 1/2 and so seas or in between.

11:30.710 --> 11:40.670
So we are in between the two sea and some is the some off and so some is the some oftenest OK.

11:40.710 --> 11:44.700
And we'll be finding this, some is connected to the orphanage too.

11:44.780 --> 11:49.840
So this summit's connected to you of an issue and this cat is connected to.

11:50.030 --> 11:55.400
So we'll be finding an exact schematic where we can visually compare the circuit that has been implemented

11:55.520 --> 11:56.900
by the code that we have it.

11:57.320 --> 12:02.020
This gives us more insight and we'll be finding if we perform a simulation, this will work fine.

12:02.060 --> 12:06.170
So now we have understood how we do an implicit real declaration.

12:06.560 --> 12:10.850
Let us understand what is an explicit we called declaration.

12:12.710 --> 12:19.970
OK, so what we'll do is we'll just comment this also coming this out, we have an hifi, OK, so you

12:19.970 --> 12:22.950
decide to halfpence and that will invoke a comedian.

12:23.540 --> 12:23.810
Right.

12:24.050 --> 12:28.330
So first you then actually, which is an instance name, then we have an itchy.

12:34.510 --> 12:39.900
OK, then we have a pool now here when we use an explicit declaration, the position doesn't matter.

12:40.060 --> 12:45.640
OK, so for example, we can start with the sun, OK, even though the first boat incident happened.

12:46.360 --> 12:53.090
But I've started with in some and I want to connect some to even look at it to a..

12:53.200 --> 12:57.040
To eat can be to be OK.

12:57.070 --> 13:02.800
So here the first difference that you'll be finding between an implicit and explicit is for an explicit

13:02.800 --> 13:08.290
way of declaring you do not need to worry about the position of position are automatically understood

13:08.560 --> 13:14.080
by the way you specify the object and then they will be finding here also.

13:14.080 --> 13:16.090
And you can in fact use both.

13:17.080 --> 13:24.880
In the same clothes, so it doesn't matter whether you use who, though who or you define Budokan with

13:24.880 --> 13:28.430
an explicit, Budokan with an implicit or you use mix.

13:28.430 --> 13:32.200
So, for example, here, what I should be doing is I'll be using.

13:33.280 --> 13:39.130
Tomorrow, I'll be declaring one auto company with an explicit week, while the other company we have

13:39.130 --> 13:45.490
declared with an implicit OK, so even though we have mixed view of declaring a quote, if I just sue

13:45.490 --> 13:48.670
Michael and if I try to reload a schematic.

13:51.280 --> 13:53.290
Still, you will be finding a seamless.

13:55.450 --> 14:00.080
So if I just go to a schematic still, you will be finding a scene with no difference at all.

14:00.430 --> 14:06.700
But whenever you have a larger component, see that you stick around with an explicit way for a simple.

14:07.670 --> 14:10.790
Component, you can use an implicit way of declaring, right?

14:11.090 --> 14:16.340
So this gives us a fundamental insight about the structural model itself will consider, for example,

14:16.520 --> 14:18.110
to get a good understanding of the.
