That's exactly what you said, it's the expectation you gotta live up to. You're not here for jokes and games, you're here for the win games, and that's what we're gonna do. They let go Adrian yesterday and sign you to the active roster. That's gotta feel fairly good, especially coming off your strong performance on Sunday. That's one of my main guys, Asian PS, and was the best luck to him. For me, it's a duty to me, but at the same time, I'm not here for that. I'm here for the win games, and I'm not here to compete with my teammates as far as that aspect. What's the process like coming in and trying to get up to speed, and maybe what's your comfort level now compared to when you first came in? It's been a grind since I got here. It's gonna continue to be one, and I'm here to come up for the title. Mike Graver mentioned how it was a whirlwind, you know, you had to learn third down stuff and all that. How did you go about being able to catch on and have a contribution as a man? It's just focusing on the details, the little things that's really what matters in this game, especially in today's games. You just gotta hone in on the details, and that's what I did.


How to Control Effectively, Key Suggestions for Perfect Classroom Management Classroom management is a topic that is so broad, so overwhelming that it's hard to know where to begin. A group of people coming together to learn a common subject or topic under the guidance of an instructor is called a class. The people taking the instructions are called learners and the place where the instruction takes place is called the classroom. Ensuring the smooth and uninterrupted learning environment in a classroom so that teaching takes place successfully is called classroom management. Progressively I will be discussing the strategies used to achieve effective classroom management. Key Strategies Classroom management strategies can, therefore, be defined as the methods and techniques an instructor uses to maintain a classroom environment that is conducive for students learning and success. Although there are many pedagogical strategies involved in managing a classroom, a common classroom management setup should ensure that learners feel they are in a conducive environment. To achieve effective classroom management, the following strategies can be implemented. Positive Relationship Establish a positive relationship with the class. Learning should be fun and exciting. Nobody wants to spend time in a classroom where lecturing and note-taking are the norms. Students love creative, engaging lessons that grab their attention and allow them to take ownership of the learning process. Every student has a passion for something. Teachers should use these interests and passions to their advantage by incorporating them into their lessons. Students love teachers who incorporate creative and fun engaging activities into their daily classroom. Also, teachers should incorporate humor into their daily lessons. This may be sharing an appropriate joke related to the content you will be teaching that day. Rules Set classroom rules. These are the first line of defense against misbehavior. The rules should be simple in a way learners should be able to understand what they mean when they are first introduced. The rules must be definable, it should be known without a doubt and able to communicate exactly what is and isn't okay. Any uncertainty over what constitute breaking rules leads to arguing and vexation. The rules must cover every possible behavior. If you enforce a consequence, but can't confidently cite what rule was broken, then your students won't trust you. The learners must know when they have broken a rule and exactly which one or they won't take responsibility for their behavior. Encouragement Praise your students. Praise can be a very important tool to transform a student's image, uplift the entire class and enforce the values you seek to promote in your classroom. It will be important to be specific when praising students, it should be perceived and sincere, earn and truthful, immediate and unexpected. Example of praises you can give to your students are, you're smart, you're very kind, excellent, very good, good job, well done just to name a few. Encourage group projects. Working as a group is very important as weaker students turn to learn from stronger students. Students who work with each other inside and outside the classroom also might develop more respect for each other. Some students will develop leadership skills while others will learn to be more responsible about completing assignments especially when there is a group grade involved. Also working as a group gives students the opportunity to connect with one another. Do you want to teach English abroad? Conclusively, while applying these strategies, the teachers should always be in control of their class by ensuring the enforcement of the rules. Also bringing excitement into your lesson improves students' interest to learn and sometimes teachers are advised to even go the extra mile to make the classroom conducive and interesting for the student. Speak with an ITTT advisor today to put together your personal plan for teaching English abroad. Send us an email or call us toll free at 1-800-490-0531 to speak with an ITTT advisor today.


Hold on. Can I get cheaper lenses for myself? I had bi-weekly lenses and I was kind of getting like an eye infection every couple of months I just started researching the top manufacturers started to reach out to them. Hey, I'm doing a university project Was any of this true? Semi-true. I was doing an entrepreneurship course at the time, but a contact lens project was not one of my projects So kind of half true. I asked them to send me pricing when I started to look at how much they cost to produce I felt really ripped off as a consumer and I realized that maybe it would be possible to sell high-quality contact lenses like 30% cheaper and in parallel give the customer an experience that makes them want to engage with eye care


Assalamu alaikum dear students, today we are going to do lecture number 7 of the database management system course. In the lecture number 6, we concluded our discussion on the data flow diagrams. There finally we discussed the detailed DFT and how they are linked with the higher level diagrams. After that, we also discussed the second phase of the database design process where we discussed the design phase. We discussed why do we have different types of database design. We also discussed the data models. What is the link between data model, database management system and the database design? Why to have different data models and what are the different types of data models? At the end of our previous lecture, we were about to discuss the ER data model that is basically a conceptual database, conceptual data model. Today we will start our discussion on the ER data model. So let us start our today's lecture. As we have already discussed in the previous lecture that ER data model is a semantic data model. That is, it is a data model that provides you more constructs, more tools to fit in in different situations. So the advantage is when you draw, when you make a design using the ER data model, it is more explanatory. It is clearer to understand, it portrays, it models more information into the design. As you can see from here the definition, a semantic data model used for the graphical representation of the conceptual database design. As I have told you before that your graphical symbols, since they have very precise meaning, clear meaning, so there is no conflict what they are representing. Second thing is the objective has always been that in this type of tools, we have fewer number of symbols. So with less symbols, we can give more meaning, more work, this objective is our conceptual data model. Let us move forward. What are the major components of the ER data model? It is the entities, the number of attributes, and then the relationships. These are the major components of the model, with which we make different designs. But there are also other things that are added in it, these are all different types that all of them together make their own meaning, which we will study in the next lectures and in this lecture. Dear students, Entity is such a term that I would like you to have clear concepts in your mind. This is also among the basics about which I always expect you to be clear about those things. Entity terms are basically three different things on different occasions that are used to give meaning to them.  After that, it is better that whenever you use a term, you use the same term that you would like to use. But first of all, if you are using an entity term or you are using an entity term, then you should have in your mind that at this moment in this particular scenario or this particular context, which particular meaning of the entity you are using? What are those three different meanings that we mean by the term entity? Let us see them. First one is entity type. Second is entity instance. And third one is entity set. One term is entity. These three meanings are used in different occasions and different scenarios. And to understand a scenario, you need to know that at this particular moment, what is the meaning of entities? But otherwise, I would recommend that at every moment, you should use a special term, i.e. whatever you mean by these three meanings. But this does not mean that if you only use the term entity, it will be wrong for any of these meanings. By the way, let me also tell you that when we use the term entity, that is generally meaning the first two meanings. Usually, that means entity type and entity instance. Now, it depends on you whether you see the figures or the context. What is the meaning of that? In this course, when we use the term entity, that means entity type. If we take the first two meanings in the books or in different places, let us see what each of them means. First of all, entity type. Entity type is a label or name assigned to items or objects that exist in an environment and that have similar properties. It could be person, place, event or even concept. Dear students, this is a technical work. With an experience, you will be aware of how do we identify entity types? How do we declare the entity types? When you observe any system, all the things that exist in any place have properties of each of them. You can easily identify them. For example, if you see any event in your bedroom, you will see different things there. For example, there is a bed, there can be a chair, there can be a maze, there can be a fan in your room, there can be a bulb in your room, there can be a TV in your room or a CD player in your room. For example, there is a picture in your room. There are different things that can be in any room or bedroom. Similarly, you can take any place or any system. Now, if you talk about your bedroom, there are properties of each of the different things. For example, if you look at the bed, it is made of a special material. It has a special purpose. You look at the chair, its material is its own, its structure is its own, its purpose is something else.  Each of these things has its own properties. The properties of each of these things are common. They are the same. You can describe the properties of each of these things using the same properties. So, most tentatively, most probably, those things would be belonging to the same entity type. For example, if we talk about the bedroom, some of the things that I have mentioned, which can be in your bedroom, some of them you can say that these are the furniture. Similarly, some of the things you can say are electronic or electrical equipment. So, when you observe any system, when you analyze it, the things that you see there are common properties. Based on those common properties, you can say that these things fall in some category, we give them this label. These are the things, because they have their own properties, so we fall them in this category. And look here, one thing to keep in mind is that the property and the value of property, they are two different things. For example, when we say that we said bed and chair. Now, the common thing is that they are made of wood, for one purpose, for seating, or for bedding. But that chair is a bed. So, although both belong to the furniture, we can say that they are furniture, but they are different. If I give you another example, if you look at a classroom, in any classroom, if you look at the things that you see, in that, obviously, you can see a teacher, there will be a rostrum, there will be a whiteboard, there will be a blackboard, there will be chairs, there will be students. So, when you analyze these things, when you observe them, all the things that are present there, if you look at their properties, based on those properties, they relate to each other, or they can say that they feel the same way. So, if the human beings here, the people here, you can say that these are the persons. Then the thing is that the other things, they could be the electrical equipment, they could be the furniture, they could be the fixtures. Similarly, you can say that there are teaching aids, there is a whiteboard, there is a marker, there is multimedia, there is a computer lying there. So, when you analyze any environment like this, and from there, you make a different group based on the common properties of things, and you give that group a label. That label is basically a name of an entity, or you can say that it is an entity type. You can identify an entity type on another basis, that when your users tell you their requirements, you can identify those different entity types. Why? Because those requirements are something that is common in them. In the last lecture, we talked about the cross-reference matrix. In that, I told you that the different reports, the documents, the transactions, the different data items, the attributes that you need, you can make a matrix, a table. Similarly, the things that come on a single report, the things that are involved in a transaction, the things that are involved in a document, most likely, not necessarily, but most likely, they can be declared, they can be identified as a single entity type. Or, it is possible that they are two different entity types, but they are somehow linked with each other. This will be clear to you, but at least you have noticed that the cross-reference table that we made, the cross-reference matrix, you can use it here as well, which are the things that you can identify as entity type. Whether you make a cross-reference matrix, or not, even then, you can identify the entity types from an environment. Let's move forward. What is special about them is that based on these properties, you can differentiate them from the other entity types in that environment. For example, you will not call a bulb a furniture, why not? Because the properties of furniture that you identify, the properties associated with furniture, they are not in the bulb. You won't declare a chair as an electrical equipment, unless it is an electrical chair, unless it is an electrical chair, but by the way, a sitting chair that you won't declare is it as an electrical equipment. You will not call the air-condition as something in which you drink water. You will not declare it as a utensil, you will not call it as a vessel. This means that when you find an entity type, when you declare an entity type, you will be able to differentiate it from the other entity type, based on their properties. Entity types are identified through a process called abstraction. Abstraction is a term that is defined in different places. But what we define in this scenario is that it is an thinking process. It is an intellectual process through which you separate and identify the common properties of things. Again, the abstraction is a thinking process, an analysis process in which you identify the common properties of the things that exist within an environment. So, as I told you earlier, if you have a tool whether it is a dictionary or a cross reference matrix that can help you, that can work as an aid and the second is your abstraction process. The abstraction process relates to your thinking ability and the second is experience. Initially, it is possible that you have a problem identifying an entity type or a proper entity type but as you experience it in the database development process it is possible that you can do it in a better or easier way. Another factor is that if you have got experience on working on the same type of system once, twice, first you have worked on the banking system twice, three times. So, this will never be the same design or the same process but your abstraction process that will become easier because you have already worked on that kind of environment or you have already identified the entity types of that environment. Let us move on. A very important point. The entity or the entity type in the ER data model and the external entity in the DFD, they are different. This thing is confusing for many students because in both of them there is a lot of similarity but the biggest difference is that the external entity in DFD you define anything that generates data to the system or accepts data from the system that is an external entity or entity in the DFD and here we call the entity type or entity that is a distinguishable thing in an environment based on its properties that is the entity type or entity. Another thing that is confusing is that the symbols are the same both are represented by the rectangles but one thing to note is that their definition is that in DFD anything that receives data or accepts data from the system is an external entity. One thing to note is that there is a single entity that exists in that environment. For example let us talk about the bank. The manager he is a single person he has a single existence in that environment but if that banking system accepts data or produces data obviously he does then he will be represented there. If we talk about a library system then the librarian is a single thing similarly if we talk about the university then the VC the registrar he has a single existence he is a single person in that environment. But if he is producing or receiving data then he will be represented in DFD. If we talk about ER data model or when you are designing a database using ER data model or your conceptual database design then you will not show those entities their single instance. This means if you are developing a banking system you won't generally represent the manager. If you are developing a library system you won't represent the librarian. If you are representing a university system you won't show the type the registrar you won't show the entity type because the instance where the data will be a single record. The representation of such things using your ER data model you won't represent the conceptual data design whereas these things will be represented in your DFD The DFD provides you a basis so that you can identify the entity types. It is absolutely possible that the many entities of your DFD external entities you can take your conceptual database design using the ER data model but it is not necessary that all the external entities will come in your ER database design. Now let's see what is the entity instance and entity set. We have discussed the entity type You define entity instance as a particular object belonging to a particular entity type For example we have identified an entity type employee because what we have seen there are many common properties based on that there is an entity type which is an employee Now any entity related to that entity will be called an instance For example An entity instance Muhammad Sharif all the data is an instance of the entity type The entity type defined a category based on the properties and after that any property that keeps those properties has no value For example the entity type has a name the entity type has a date of joining has a qualification has a sex has a date of birth All the properties we have identified and based on that we have an entity type employee All the employees have their own name their date of birth their qualification and date of joining usually that is an instance of the entity type employee entity set all those instances which belong to a particular entity type if we see them jointly that will declare as an entity set This means that in a factory all the employees working jointly we will say this is an entity set whether it is 1, 2, 10 or 1,000 we will say entity set We have explained what are the different meanings in which we use the term entity entity type, entity instance and entity set I hope these terms are not clear to you I will repeat whenever you use the term it is better to use the precise term but if you use the term entity then you should be clear what is your meaning Let's move on Types of entity types You have said what is entity type that we have given a name based on properties but in the ER data model there are different types Let's see what they are Broadly We divide them into two categories One is Strong or Independent or Regular entity types and the other is Weak or Dependent entity types What is the difference between these two Let's move on to the next slide We are first going to discuss the principles of common life Here you have a little more technical An entity type whose instance cannot exist in a system as long as it is not written by any other entity type We will say it is a weak entity type or it is a dependent entity type This means the instances of that entity type cannot exist independently In addition such entity types whose instances can exist independently without being linked to the instance of any other entity type we will say Strong entity type or Independent or Regular entity type I will give you some examples of Strong and Weak entity types For example if we see we have a factory we have employees The rule of the factory is that the dependents of any employee who are their parents who depend on them are also storing their data Obviously if we say we want to store the data of any employee's dependents they cannot exist without the existence of employee as long as you do not link the dependent with any employee how can the dependents come if you can describe it that the factory the business the link with any employee that is through the employee If there is an employee then it will be dependent There is no question that there are dependents but who is dependent? The business would have no concern with those dependents This means that you cannot put the instances you cannot think of the instances of the weak entity type as long as they cannot be linked they cannot be associated with any strong entity type like I have given you an example of dependents and employees It can be an employee type Employees can exist independently If there are no dependents of any employee he is all alone or his parents are not dependent we have employees but they are not dependent but it cannot be an employee It means that dependents cannot exist until they are linked This is an example of the weak entity type and the strong entity type Another technical thing which is more clear that the strong entity types have their own identity that is you can identify them There are some properties that you can identify but normally the weak entity types do not have their own identity and to identify them you have to find you have to relate it with the identification of the strong entity type like we have an example of dependents and employees that if you want to identify a particular dependent then you have to link it for that the employee that is dependent you have to link it with their identity This is also a difference between the strong entity type and the weak entity type These are the naming conventions for the entity types and mind it these are just recommendations these are the rules these are the steps that normally professionals follow but this is not necessary for you for example it is said that for entity types use singular nouns like student, class registration or employee and mind it that you do not have to use the names according to your own needs but you have to see the convention at the organization what is being used there what customers call it the common term used in the organization is the client it is good to say you can call the client a customer but the recommendation is to use the same terminology that is used in the organization what will be the benefit of it that when you are discussing the design, the diagram or the general scenario you will use the same terminology so the user will quickly pick it and easily understand it if you change the terminology then it is possible to relate the user it is recommended that the name of the entity type is written in the capital letter sometimes you will see that it is written in the mix or in the lore but it is recommended that it is written in the capital sometimes you can use abbreviations that if the name of an entity type is very big if you are making a diagram and it is not fitting then you can use it in abbreviations but one more thing that in this you have to be consistent if you do the first thing you make the employee EMP or you make the student STD or you make the registration REG then you use the same terminology in every design so you can use something else and something else so if you get different spellings it is possible that they become different things from it although you meant one thing but they will become two different things till now you had seen what are the strong entity types and what are the weak entity types now since we have talked about that your ER data model is a graphical representation it consists of the symbols now what you can see on the screen these are two different symbols that you use for weak entity type the difference is the strong entity type you use a solid line and the weak entity type has a solid line but it has a double line so the weakness to give it more power you close it in two lines in the middle we can see the name here you will write the name of the entity type for example as you can see employee and dependents the line between them is basically linked now we have not drawn the line correctly we will read the rules of the drawing later but for now consider that this diagram shows that the employee is linked with the dependent one thing that the employee is a strong entity type and the dependent is a weak entity type and this is the beauty that you have a semantic data model with some symbols you have given a lot of meaning to describe that you need a paragraph more explanation for example you have books but there are multiple copies so in that you want to store the data separately about the book and the copies separately why do we do this? maybe you do not understand but think as you can see the figure shows that the book is an independent entity type and the book copy can be one or ten or twenty the question of the existence of the copy of the book is not there so in the same way the copy entity type is a weak entity type and the book is a strong entity type let us go ahead attribute is the other construct that is provided in the ER data model attribute basically shows the property we have already talked that when you identify an entity type that you identify based on the properties of the entity type the properties of the entity type you represent them due to the attribute that is the term which is used in the database world especially in the ER data model language the attribute means the property associated with a particular entity type for example if we say we have an entity type the property of the entity type is its name in the data model language we will say the entity type employee has got an attribute name we will say the property of an employee we will say the entity type employee has got an attribute named date of birth and this can be another example one more thing is you have defined the entity type then you will associate the different attributes associated with the entity type for example now all the instances all the instances will have that attribute applicable when you say that the employee has a name, a father name, an address date of birth, a sex, a baby date a joining date, an experience all these are attributes of the entity type employee when you define the entity type after that all the instances associated with the entity type will be associated the difference is that in the case of instances these attributes will have values meaning what you have identified the entity type, the attributes when the instance will come then all these attributes will have value and that will be the entire instance domain of an attribute before that when we identify the attribute when we define it the entity type has a name the attribute name the property name name, date of birth these are basically the names of the attributes the second thing is that every attribute has a domain what does it mean by domain domain means set of possible values for an attribute when you have identified an entity type after that when you take the instance of that entity type then the value of every instance in that particular attribute where will that value come from what set of values where possible an instance will take the value of that attribute this is a very useful thing this is a sort of check on the value of the attribute for example age is an attribute now the question is if we have 10,000 employees each of them has an attribute of age where will that value come from what set of values where this age value can come from tell me can you think that XYZ is a valid age value no XYZ does not mean it is a valid age value it can be but otherwise normally XYZ or ABC or star-dollar these are not the valid values for the age attribute domains also mean after identifying the attribute after defining the attribute you associate a domain with it when the domain is associated on that attribute then it becomes clear that the value of this attribute can come from any of the possible values for example what is the value of this attribute let us say aslam hussain aslam hussain is not a proper value for the salary obviously the value of this attribute can be a figure this attribute its value should come from the numbers and the domain gives you an additional beauty that you can check the boundary through it for example if we say that our electricity or gas bill how much is our bill in a month the first thing we say is that it will be a number but is it possible that someone's bill will be minus 2000 what does minus mean gas also means that wabda is giving us money that you have used our business money no it means that the value on the minus of the bill is not a legal value then you associate the domain with another check with the domain that it cannot be negative it will always be positive so that we pay wabda that we have used our business money when you say that we have an entry type its instances are called entity set so all instances one attribute when you define the domain the value of that attribute will be assigned to all instances from the same domain that means if you say that the age will be the number then after that you add thousands of lakhs of instances against that entity set all the attributes when your attribute is age the value of that attribute will come from the same domain the domain you have defined with that attribute that means when you have an entity or an attribute you have to be careful you should think what is possible value of this attribute this can also cause a serious problem for example if you say that you have an attribute we talk about the value of that attribute or the salary you have said that it can increase from 4 digits and cause a serious problem now you have defined you will be a bit careless you have defined but you have realized that maybe in some exceptional case the value of that attribute can increase from 4 digits so when that situation comes that entity type that value cannot be accepted there can be two cases one case is that it will give you an error if you give an error then it is a very good thing because you will solve it but the most dangerous thing is that it will not give you an error message and it will do an unpredictable activity which may not direct you and this is very dangerous in a working environment and it cannot detect because it can be detected at a very serious place when it has done a good damage so I hope that you have realized the importance of the domain Dear students the slide you are seeing you can see there are different types of attributes that we use in the ER data model the first category is Single vs Composite this means when you design your database then some attributes value as a single thing as a single value which means their value is on one thing on a single thing while some attributes are like which are made from other attributes we call them composite attributes for example like age birth these are single attributes because there is only one value but the address in the address we have an attribute which includes other attributes for example street number house number sector, city, province and it can contribute so all these things can form a single attribute called the address these attributes that jointly make the address attribute they will be called the components of this attribute the address or the address this will be called a composite attribute here again I will tell you that there is no hard and fast rule which thing you will model as a single attribute depends upon your system what is the requirement there as you will remember when we did an example in which we had a user he was looking at the name as first name and last name so if you have a requirement like most of the people they see it as a breakup so even you can define the name it consists of first name like I have given you an example of address if you have a requirement like most of your application the user's requirements the address is seen as a single thing like okay what is the address of the student what is the address of the student instead of that you can model it as a composite attribute what is the need for you to make extra effort or to break up you can store it as a single string as a text in which it will say house number E2 street number 33 sector G61 Islamabad Pakistan so it will come as a single thing in this case even address that is being modeled as a single attribute but if your application is like whose requirement is that they want a different house number so in that case what you will do is you will store it as a composite attribute what is the benefit of that the benefit is that whatever applications you want they will be present in your database design here is another thing first you have 25 applications that use the address now the thing is there are some applications that use the whole there are some applications that use different addresses now you can use the address as a single attribute or as a composite attribute you can justify both the applications so what you should do the question is what are the requirements for example there are 24 applications that use the address as a single thing so what you will do is you will do it over you will do when you analyze the address and break it up but the other 25 the other 24 you will hold the address and show it to them if you break up the address i.e. you break it up as a composite attribute then what will happen that one application is easy that you already have you can show it to them but the other 24 applications you will have to mix them and then add the address you will not have to do any labor but this is an extra activity this is some additional processing that is happening in many applications in other cases you will have to do only one application i hope you have understood what is the difference and what should we do Dear students do not get confused that in any environment there is nothing to do there is always a whole lot of options this is correct you should know that there are different ways you should know the benefit of every way then it depends on your choice depending on your thinking depending on your analysis whatever is better in an environment you should adopt it let us move on the second type of attributes is single-valued and multi-valued the difference is that sometimes your attributes have one value but some attributes have multiple values for example if you say a name aslam but but if you see there are hobbies hobbies can be multiple 1, 2, 3 4, 5, 6 if you see degrees or qualification there is a attribute in which people have multiple values some attributes are single-valued some are multiple-valued similarly stored versus derived some attributes usually your attributes are whose value you have stored but some attributes are whose values you do not store but you derive them from any other attribute for example if you associate with an anti-type date of birth and age you have stored date of birth but you did not store the value in fact whenever you access the age attribute there is a routine which will take value from age date of birth and calculate it so this is an example of stored versus derived attributes I hope you have understood right now the slide on the screen you can see there is a symbol of an anti-type you can see an oval shape this oval shape that is used to represent an attribute in the ER data model and this indicates that you will use an oval for every attribute if there are some approaches for the brevity purposes they combine different attributes but normally this is not recommended there are many attributes with an anti-type you will represent every one with an oval this oval is linked with the anti-type as you can see here we will see which symbols are used for different attributes which attributes are used this is used for the simple attributes which have a single value this is used for the composite attributes you can see as I told you in the last slide the symbol of your attribute is an oval that would be linked with an anti-type but in the case of a composite attribute the component attributes will be linked with the attribute the component attribute will be linked and this is the only case when the oval is not linked with the rectangle and oval is linked with another oval that means the component attributes are linked with the composite attribute and the composite attribute this will be linked with the anti-type associated with it this symbol is used for multi-valued attributes as I gave you the example of hobby or qualification this symbol is used for the multi-valued attributes all these attributes are linked with an anti-type this is an example of an anti-type employee all the attributes are shown here for example experience the experience is shown as a derived attribute because the experience is derived from the attribute date hired if you see the employee ID since the single solid line is shown it means it is a simple attribute single-valued attribute it means it is a simple attribute single-valued attribute if you look at the address if you look at the address it is represented as a composite attribute these attributes are street and house number and the symbols of both the attributes they are not linked with the anti-type employee rather they are linked with the attribute address the address here becomes a composite attribute when you have an employee qualification it is basically a multi-valued attribute as we have shown with double oval obviously your date is hired this is also an attribute with a single line it means it is a single-valued and a simple attribute apart from this if you look at the naming convention you will get an idea where the employee entity type is named it is in the capital letters but the attribute you have is normally represented in the lower case and if you look at the two words as I have mentioned here amp name we have made amp in the lower case just to show that there is another word we have made amp in the capital so this is a recommended convention it is not necessary to follow dear students we will wind up today's lecture as you have seen in today's lecture entity relationship data model this is a semantic data model which has a feature which is a semantically rich data model you use this for conceptual data-based design today we have read some constructs in which there was entity type we have read different entity types after that we have read another construct attribute and then what is the difference and how are the links in the next lecture we will discuss the relationship Allah Hafiz


And I'm going to show you your user. And this should not matter. And it's AMP's mission to make it not matter. We're going to talk about this morning about freedom. We want to be free from being stuck on one version control system or only going to easily use one version control system. AMP wants to be a familiar, customizable interface to every version control system. I'm going to describe what AMP is, why AMP matters, what AMP will do for you, how you use it, and how you can help. So my own version control journey, when I went to college, there was no concept of version control. We kind of did our little projects. Did anybody actually get introduced to version control in school or education? OK, there's one, that's two, that's some progress. When I went off and actually got a job, then I was introduced to VisualSrsafe. Any VisualSrsafe passed, hopefully, users out there? Yep. So it was a small company. So it was pretty much lock the entire project, check in once a day, and hey, it's a backup, right? So I eventually started reading about other systems and things. And I moved that company over to Subversion to get things going a little bit better. I'd heard about distributed version control at this point, but it was a conservative company, small teams. I was up with a centralized system in Agui to kind of help everybody through that transition. But over time, I was starting to kind of wake up from being just an employee and said, OK, I need something for my own projects. So OK, now I want to investigate distributed version control. I'm not under the same constraints anymore. Now, I narrowed my field down to Git and Mercurial at that time. And then keep in mind, this was 2007. I was making this choice. Some things have changed since then. Everything I read said that Git had this really arcane kind of command set, whereas Mercurial was a lot cleaner. Using Subversion, I also got used to the Subversion online book, which was a very useful introductory reference. And there was a version of that for Mercurial, which later became an actual printed book. I was not aware of anything that kind of had that same level of tutorial quality for Git then. The company I was working for, also, we had primarily Windows machines. I didn't want to cut anybody off. Git's Windows story was still kind of shaky at that point. You could kind of sort of get it to work under SIGWIN, but it still wasn't quite all there yet. So at that time, in 2007, I made my choice on Mercurial and eventually moved that company over to that. That was 2007. In 2008, GitHub came along, and Ruby and a lot of other communities kind of went over that way. Since then, I've certainly used Git, branching, rebasing, all that fun stuff, although a lot of my repositories are still in Mercurial. So that is where I'm coming from if anyone wants to try and evaluate any biases I may have. There's my reminder. All right, so what is AMP? AMP is a familiar, customizable interface to every version controller repository, or it's trying to be. It wants to give you your familiar interface to your version control through a common API to every repository that you might want to access without having to learn its new conventions and things. Now while its goal is to be an interface to every version control repository, what you'll get if you install it right now is full Mercurial support. And I'll explain why it's that instead of Git as we move along here. But that's where I started from. So it also wants to be familiar and customizable. So it has a flexible command system with commands that are written in Ruby. So you have the complete power of a general purpose language available to write custom commands and extensions and things. AMP was written by Michael Edgar and Erie Brown, operating under Kibarnica. And Michael actually rearranged his schedule to come down here to RubyCon today. So I'm certainly glad to be meeting up with him. So the name AMP is a little bit of a play on Rails, which apparently is a slang term for cocaine, which DHS was even talking about earlier today, which puts a whole new spin on Ruby on Rails. So going to some features of local nearby towns, they decided to make AMP a play on meth. Even though it's not an obviously drug-related thing, but it's a short term that kind of followed along from that precedent set by Rails there. So they had the problem of who wants to make this general purpose version control system. And how do you do that? How would you make a version control system? And seriously, where would you start? Anybody? Now, where you'd start? Yep, yep, read the other ones. So when they started this project, they said, OK, we're going to start with the material implementation. Essentially, clone that into Ruby, and then we'll refactor and whatnot from there. This gave them an existing implementation in a dynamic language. It wasn't as big a leap as going from something that was written in C or some other language. So it could translate more or less without as much a conceptual conflict or dissonance there. One of the things that happened because of that is that since Mercurial was GPL, AMP as a derived implementation of that necessarily became GPL, even though they might have preferred a more open license like the Ruby license or MIT or something like that. So it actually essentially completed that conversion. They got complete implementation of the Mercurial API as something we can start testing and playing around with and building upon for the other systems. So what I've just described is AMP 053, which was done under the title of John Locke. And I'll be using that name to refer to that version of AMP as we go through this presentation. And that sort of icon will signify I'm talking about what you'll gem install today. I heard about AMP a while ago, and I didn't really get into it right away just because of timing and things. But I finally had time to do that. So I went and I found the AMP web page, said, OK, there's lots of information here. I've got examples. I've got a little bit of explanation of how things work. I've got pointers to the code repository. Things have been recently updated, so the project is definitely still alive. We're starting to see the Git support coming in, so this is a good thing. I know that'll help the Ruby adoption a lot. But as time went on, I went and I got back into it. So I went in, found some tests that needed some help, some things that weren't working, made some patches. Things were all looking good. So I went ahead and threw off my second proposal, a Ruby con. And then things got a little more interesting. As time went on, I checked back, did some more patches and things. The main repository still hadn't been updated. And the AMP web page disappeared. And as you can probably guess by the fact that I'm here now, the proposal got accepted. And it's like, well, that's interesting. I hope I'm not doing a funeral speech. No, the repository still hadn't been updated. So I said, OK. I remember there was this out of date mirror on GitHub, so maybe they actually switched over to there. And well, no, there were no updates there either. But hey, what's the SAMP Redux thing? So there's something going on here. So this is where I finally emailed Mike and Erin and said, hey, what's going on? And in fact, they had been doing some internships and other distractions. They had a cheap web host. So that was something that it's taken care of. And one of the things I found out is that, yes, they had started to do the git implementation, and then things got a little bit more interesting. It turned out to be a little bit trickier than it first expected. And this isn't really all that surprising considering that they started with essentially a clone of the Mercurial source. Git does not have as close of an overlap with that set of concepts. And in particular, what this started to point out is that Mercurial was very tied in with its concept of what files are stored where and how they are stored. It didn't present quite the higher level interface to version control that they wanted to present in order to easily cover everything. So taking this together with the licensing issues, I said, OK, it's time to start this thing over. We've learned a lot from it. And now, taking together what they learned from doing John Locke together with other experience, it's time to take that and taking a lot of that code, but restructuring it into a new system. And this is part of the mission of AMP, to learn how to build large Ruby systems, and as well as learning how to build version control systems. So maybe it'll take a few iterations. As much as it might have been nice to plan for this, at least it's nice to have that milestone out of the way. So this brings us to AMP Redux. And the less you think I'm trying to mislead you by talking about two versus the vamp, I will be attempting to clearly identify John Locke, which you can install today, from AMP Redux, which is coming along nicely, but is still kind of in a period of major reorganizing right now. So as I said, Mike and Ari, we're off doing internships and things. They're learning a lot about software engineering and pulling that into how the new design of AMP. They're separating, making a better separation of interface from implementation, so we don't have that same sort of tied-into mercurial or what-have-you. There's a higher level interface, and then below that you'll have the parts that deal with the messy bits. AMP Redux will be a more modular system. The primary modules at this point are AMP Front, which is sort of a general command line shell that will be a plug-in host for the rest of it. AMP Core will turn it into a version control system and have these sort of general support libraries and things. And then you'll have all of the repository formats and eventually command sets for that. So AMP is trying to be a familiar, customizable interface to every version control repository. Here's my reminder again. Excuse me. All right. So why does AMP matter? Well, I imagine that most of you, thanks to GitHub, are using Git. Git is written in C. Git's arch-rival mercurial is written in Ruby's arch-rival Python, as is bizarre. There's a system called Dark's written as perhaps slightly more palatable Haskell. There's a monotone, one of the original distributed systems in C++. The big gorilla subversion is written in C. There's a distributed version of that called SVK that's written in Perl. And if you add all these up, there's something missing here. In fact, if you go to, for instance, Wikipedia's comparison of revision control software and do a search for Ruby, you're not going to find a whole lot. Apparently, nobody thinks that Ruby is a viable system for a mission control piece of software like a version control system. And one of AMP's missions is to prove that it is viable for large-scale applications. So AMP is trying to become a familiar, customizable interface to every version control repository. And despite its goals, someone will inevitably ask, do we really need another version control system? I mean, really? Well, at times, I'm sure people have asked, do we really need another implementation of Ruby?  We've got MRI. Isn't that good enough? And yet, some people said we want one in Java. Some people said they wanted one in small talk, but those guys are next door. Some people said, we think that writing things in Ruby is a really nice way to get into our software systems and make them easily modified and understandable. I suppose that's where I should thank the Ruby Con for moderators for not putting the opposite of Ruby Con, or Rubinius. Ruby also made its fame through Rails. And yet, that wasn't good enough. We said, well, we'd kind of like a interface through Sinatra, or maybe we're going to do Merb, which also went back and informed Rails 3. And last night, I heard about this thing called Fog, because apparently, some people like being able to access more than one Cloud host. I mean, isn't one good enough? But 700 people think this is an interesting project. It's interesting. So AMP wants to be a familiar, customizable, interface to every version control repository. I talked about how my journey went from visual source space to subversion to Mercurio, and I've used some Git. Your journey may look a little bit different. How many people here have only used one version control system? OK. Two? OK. Three? More than three? Yep. The point here is these things change over time. There will be a next thing. And I believe that having a common API that will let you kind of access and have these similar interface to all of these different systems will put you in a better position to adapt when that next thing comes. And if you're still not convinced, all I can say is thank you. So how will AMP help you? Its aim is to be a familiar, customizable, interface to every version control repository. You can use it now to access Mercurio repos and eventually other things without necessarily having to install Python. You get both the AMP command that works essentially like the HG command, and you also get a library you can include into your Ruby code in order to programmatically access Mercurio repositories. And as AMP matures and rebuilds AMP Redux, eventually other repositories. At a more abstract level, what we have right now are version control systems that act like silos. You're pretty much talking from its command set to its repository. You'll usually get one-way imports, but this has to be redone for every new version control system to every other version control system that's already out there. You occasionally get two-way interaction like HTGit or GitSBN. The problem is this kind of has to be done for every pair. It's an n squared problem, which means this is why you don't see a lot of these things, because it'd be a pain in the butt to generate every possible combination. AMP is trying to turn this into an n plus n problem, where you define your repositories, and then you have your workflows or your ways of interfacing with those, and these become separate problems. One of the nice things that, for instance, Active Record did is it made at least all SQL-type databases look more or less the same to your code. You don't have to worry about all the little differences. Fog is doing something similar. It's giving a common Ruby interface to all of the different cloud hosting providers, so you can just say provision something and not worry about the details. AMP wants to give you the same thing for version control. It lets you take, if you're familiar with Git, use your Git commands, and it will let you talk to any database that's out there, or repository. And you can say that, OK, I'm happy with Git. And for your own projects, that's great. But what if you want to contribute to Firefox? That's a mercurial repository. The same thing for Addium, the same thing for Vim. Inkscape is in subversion. That's another system you might have to learn. Or in your own system, you've got your comfortable tools, you've got your custom commands, extensions, maybe you've got a history visualizer. If you move to a different repository, you've got to go find all those tools again. So part of AMP's mission is to let you customize how you interact with all of these repositories. Use your command set, be that Git or a customized version of that, or a completely customized workflow eventually. On the other side, if you have a project that's in a Git repository, other people, no matter what their experience with version control systems is, what their workflow is, they can contribute to that with having the added barrier of learning a new command set or repository format. This also opens up doing kind of a mix and match. Choose the command set you like, and the repository format you want based on performance or size, or whatever else you want to optimize for. So it wants to give you your familiar customizable interface to every repository format. Another thing that is interesting is that, principally at Rails 3, it's a highly modular system. And going from Rails 2 to Rails 3 and through all of this history, they've allowed you to get into more switching out your ORM, your templating engine, all of these different pieces. AMP is also trying to get that kind of modular system where you can exchange things out. So it actually opens up to easily exchanging things. So if you want to experiment with a new kind of workflow that doesn't exist, you don't have to create a repository format. You can swap out just that one piece. Back in the day, they had to rewrite Merv, essentially because they couldn't change out pieces of Rails at one at a time. Now with Rails 3, you can change out those pieces. So we have common API. We can start switching things out like that. So you can change workflows. You can experiment with new repositories that may be optimized for some new feature or frequency of updating or something without having to go create a command line system. It also wants to make extensions that will work with anything, essentially. So every version control repository has these extensions, and a lot of times they'll get the same extension or re-implemented. So every version control system has to re-implement all these extensions. Every extension has to be re-implemented for every version control system that somebody wants to use it for. AMP gives you a common API so you can rewrite these things one more time, and then you're done. They work for everything. So how do you use AMP? Well, for John Locke, which accesses material repositories, you can just gem-install it now and use it with the command line, just like you would do with HTTP or require AMP and use it in your code. One of the missions of AMP is to make highly customizable commands. As I said, it's a familiar customizable interface to every version control repository. So whereas most version control interfaces will give you key value pairs for default options and things, AMP gives you an AMP file, which is a Ruby code. So you have the full power of Ruby you're disposable to create custom commands and tweak settings and things. This is done through a system of open commands that are going to try and work like Ruby's classes. So if they are open, so the same syntax used to create a command is what you use to open it and edit it. All right. Now things get fun. There we go. All right, all right, pretty good. All right, yep, over just a little bit. All right. So I've got my AMP file in a query repository currently. So I'm going to, come on, and you always get nervous on your own stage. So hopefully I won't get too many typos here. So I'm going to open up my log command. Actually, I suppose I should do first all the fun things you forget when you're on stage. So right now if I do AMP log, I got a whole bunch of stuff. I usually like a shorter command. So I'm going to change the default of the limit option to something else. So I only get three, and of course I can still use my options to override that just like normal. So that's a very basic, this is still kind of the key value thing like you can do with anything. But the nice thing about this is that these commands are Ruby. So I happen to be in the, actually it's sort of my own version of Johnlock edge. So I am going to actually search for the AMP command. So there's mine. There is the actual AMP command for log. It is written in pure Ruby the same style you would use to create your custom commands. So if you want to see how something works, you just go look it up and see how it works, copy it. So real quick here, we've got our opening command log, just like I did for modifying it. It's assigned to a workflow. This is so you could easily switch between the get workflow, ht workflow, subversion workflow, et cetera. I should warn you that this is currently being put on the back burner for AMP Redux just to kind of focus on getting your repository stuff working. But we'll have flexible commands. So let's be pretty easy to put back. We get a description. This is what goes into the AMP help so that you get automatic help. And along with that, you get all of your options. So these are just options. These are declared with each follow up library that's included into AMP. You might be familiar with that from some other projects that use it. This also has descriptions which get put into the help. So if we do, there we go again, butterfingering things. So all of this essentially gets you automatic help. So when you're at the command line, you just say AMP help and you'll get an up to date help pulled directly from these option commands and description and things. So your custom commands will essentially get help for free once you declare your options. Let's see. OK. Then you get a block that defines how this thing runs. Is that it? All right. So you got your block. You get a bit here that this is essentially, this is almost boilerplate, just pulling out your options in these convenience variables. We do a little bit more tweaking our values and customizing things, filling in default, stuff like that. And from there, I mean, this is just ordinary Ruby iteration going over our repository. We've got our repository object just indexed by the revision you want. So this is just plain old Ruby code to pull this out. Then we've got a helper method that's built into AMP here. This is essentially taking all our change sets and running them through an ERB template. So if you've used Rails and things, you probably already know how to use this. So that is the log command. And what I'm going to do, if I remember how to do this right, is I'm going to grab that. And I'm going to come down here. And I'm going to make a custom command. And I'm going to use this in my template because I've got a let code there iterating over revisions. That's just what we need. Now I had a situation a while ago where somebody asked me to give a quote on something where I had done something similar recently, but I hadn't really been taking time for it. So I wanted a command to give me a quick summary of how long I spent doing that. So I'm going to have a custom command. I'm not going to send it for workflow. It's pretty much for everything. It's going to have a description, estimate time spent. I don't need that option. I want to limit on it. I don't need that. I don't need that. I'm going to kind of need that stuff. I'm going to do my iteration a little bit different. All right, so there's our basics. I want to use some different words here because these are the words we're doing a down to count. So I don't really like that version of, so I want to start, I want to say that's my last revision. And instead of stop, I want to say that's my first. All right, so anyway, that's just some cleanup. Actually, I'm getting ahead of myself. Because if I do, let's see, amp help, commands. That's kind of a big output. It's already in amp, if you do amp list of commands, just doing that, actually just the command billing, puts it in the amp's list of commands. If I do amp help billing, I've already got the basic description and all of the options available to me just for declaring that. So now, one of the things I pulled in essentially built into amp because it's a virtual control system is the repository object. So there, I've already got a Ruby object I can use to manipulate this with. Now what I'm particularly interested in is the particular set of change sets. And that's a lot of them. I should probably put a limit on that. Let's sort of pretend. That's a little bit more manageable. And that is the option parsing essentially giving you those two fields to put on there. Now what I actually want in this case is not change sets, but dates. So let's see, I don't want to do this. I want to map that over change sets. And I want it, not change set, not change sets. I want the, say, date. And here we went into one of the things that inherited from Mercurio, which I'm not with the plan on this is for amp redux. I would think, hopefully, cleaning this up a little bit. So Mercurio, rather, stored its dates as a time stamp and a time zone, which is not necessarily the most convenient thing you want. For the sake of speed here, I'm going to cheat and say I've already looked up that what, in fact, we want here is what John Locke called easy date, which actually gives you something, well, it's not easy to see there. If we change that to, see that a little bit easier. And these are, in fact, time objects, so we can subtract them and do all that fun stuff with them. So that is our date. Now what we actually want here is a difference between two dates. So I'm going to use a fun little Ruby method to give me pairs of things from this array. And so now I'm going to be taking pairs of things. So we've got our before and our after. And it's going to be easier to rewrite that. So what we have is you're going to want after dot easy date minus before dot easy date. So that gives me a bunch of time differences, although there's some pretty big numbers in there. So I think what we actually got here is seconds. Actually, yeah, that'll work. So what in fact we want here is hours. And no, that's not built in. I'm going to define it. So ours can take our seconds, turn that to seconds to minutes and then to hours. So that's a little bit more reasonable, although it's kind of ugly with all those decimal points on there. So I'm going to want to format this a little bit nicer. All right, so that's a little bit easier to see. But I'm not given the huge coding marathon, so I don't think I was working on this for 71 hours. I was probably doing it sleeping or something during that time. So this is where we actually get into a little bit of heuristics. What in fact what we want here is billable hours. So I'm going to go up here and I'm going to define a quick helper. And I'm just going to say, if ours is greater than 1, I'm just going to call it 0.25. Else I'm going to say it was the whole thing. So now I've got some more reasonable times to work with. And at this point, we can actually start thinking about summing this up a little bit. So I'm going to grab this as a list of times for easier reference now. All right. And actually, I want to want this to be my hours, not strings. So there's my array of raw times. So now we just want to take, actually, what I learned just today is you can be using reduce for this. I want to reduce, you know, this isn't the fastest way. So there's my time. And final touch is going to be make that puts and format. So that is a quick and dirty, usable command in, I was probably like 10 minutes, even though I kind of was going to save myself some research. I just looked up the AMP source, found something that is similar to what I wanted, and then started modifying it from there. All right. So I believe that is all of that sample. Oops, I actually wanted to skip my slides now. So AMP is a familiar and completely customizable in Ruby interface to every version control system. Well, at least it's trying to be. We've only got McHurriel now. How can you help out AMP? Well, one of the goals of AMP is to be an example of good documentation and hopefully generally good Ruby project. I was actually very impressed with the amount of effort that Mike and Ari had put into setting up their project so it would be easy to understand what's going on and how to get into it. They developed a manifesto, which actually set up the explicit goals for the project, which I've been quoting throughout this presentation. There's also a style guide in a very old testament style laying out what they expect to be in their project. And a to-do list so that new contributors have a lot of places where they can say, OK, here's where I can jump in you at a couple different levels of complexity and scope. So you have something to jump into. As I said, they're kind of refactoring into AMP Redux right now. It's going to be a modular system. The first and probably most advanced, or furthest advanced part is AMP Front. It's actually pretty far along now. That handles the command set, which includes all the option parsing through Trollup, which is also kind of feeding off that for some of the built-in help features. One of the interesting things that's going on here is that whereas in AMP John Locke, commands were instances of a command class. In AMP Redux, the commands are actually classes. So the plan is this will hopefully allow us to take advantage of Ruby class modularity mix-ins and things in order to make it easy to customize our commands. AMP Front is also a plug-in host. So essentially, this is the plug-in container. And then all of the rest of AMP is plug-ins for that container. First and most important of those is AMP Core. This is what actually turns AMP into a version control system. So it has sort of the generic concept of repository, general helpers like hashing and other sorts of support routines like that. Then you've got all your repositories. So you've got the mercurial plug-in, which will hopefully allow us to kind of contain that GPL code and make the rest of it able to be easily reused elsewhere. And then, of course, we're pushing forward on AMP Git, which has lots of interesting possibilities. I'm kind of wondering if there might be some room for diversification here, kind of having multiple backends. You could, for instance, try to do a command line wrapper around it. But it turns out they actually tried this. And Git is just really inconsistent in how it prints out its reports and things, which makes it a real pain in the butt. There's Git, of course, which is an interesting possibility. They've got some Ruby code. They're still shelling out. But they're doing a lot of the hard work for us. What AMP had started working on in the sort of edge John Locke is, was a pure Ruby implementation. And also, they want to have pure Ruby because then AMP runs everywhere Ruby runs. We don't necessarily have the portability concerns, like some of the earlier versions of Git had. And today, I learned about a project called Ribbit, which is wrapping something called LibGit2, which is sort of a library-oriented re-implementation of Git in C, so it'll still have full speed. And the Ribbit is a Ruby wrapper around that. So this will be a very interesting avenue for us to poke at. And for the review, I'm good. All right. So in review, AMP is a familiar, customizable interface to every version control system. If you want to access mature repositories, you can install it now. And you've got command line and a gem you can require and using your code. Its goal is to be free from devotion to a single version control system, to allow you to use anyone and allow everyone to use every repository, to allow you to pick how the interface you want to your repositories and to other repositories, to have extensions that you can use any extension on any repository, and write extensions that work on any repository, to have easily customized commands in the Ruby that you already know, to prove that Ruby is viable for large-scale applications, and to discover how to build large-scale applications in Ruby, and to be an example of a well-run project with good documentation. So AMP is a familiar, customizable interface to every version control repository. These are our goals. These are our tools. Now is the time. And you could help make it happen. So I'm Justin Love. Michael Edgar is right down there. Can you ask me any questions? And I'm sure if I can't answer them, he probably can. Are there any questions? John Locke was on BitBucket. I think we're pretty much primarily on GitHub for Redux, right? And everything's on GitHub now. There's your past story for everything coming. It's under just a month. The primary is under Michael Edgar is the title. I mean, if you search for AMP, you'll probably turn up one of our repositories at least. Let's see. The structure is AMP Redux is going to be eventually become AMP. So you gem-installed AMP, and it'll pull down the rest of it. And it'll pull AMP front, AMP core, AMP get, et cetera, as all the pieces. Yeah, you're building a new server for that, is that correct? OK, so the web page will be updated shortly. It's still referred to John Locke only at the moment, unfortunately. But that's coming. Anything else? All right, thank you very much.


Hello! The target of this e-presentation is to introduce a new version of Controller Area Network, CAN, Bus Protection. There is a large number of ESD and EOS standards. Some of them are dedicated to automotive applications. For data lines in automotive, the standard to be considered is ISO 10605. Car electronic systems are becoming increasingly complex as they become more fuel efficient and include ever more safety and comfort equipment. To limit the cost and weight that would be incurred with the increased wiring, designers now use buses. One of these buses is the Controller Area Network, CAN bus, mainly used for safety equipment, while the LIN bus is more suited to comfort equipment. The CAN bus is used in chassis and safety as well as engine and powertrain subsystems, where reliable functionality is imperative, so effective protection from ESD and EOS is not an option. There are many bus interfaces used in automotive applications. Some of them are limited to infotainment, whereas CAN is covering a variety of subsystems and is implemented everywhere. When cars get more complex, the number of CAN interfaces will continue to increase. CAN bus topology is made of three wires, CAN high, CAN low, and GROUND. These lines must be 24 volt tolerant in case of 24 volt jump start, but the maximum voltage must be limited in case of over voltage. This limit is often at 40 volts due to integrated circuit technology. ST Microelectronics introduced several years ago a CAN protection called ESD CAN 24-2 BLY. TLP measurement is a method to test ESD response by measuring clamping voltage at a given surge current. TLP have been performed to compare competition products and ST's ESD CAN 24. This is generally measured around 16 amps to match with the ESD standards. The TLP curve shows an advantage for ST as the clamping voltage is lower during the TLP test at 16 amps. However, the difference is small, 1 volt. Both products are very close to the 40 volt limit of the circuit to be protected. The same test has been performed on ESD CAN 01-2 BLY. At 16 amperes, the clamping voltage has been improved by 7 volts versus competition. This 7 volt improvement increases the safety margin to keep 40 volt ICs safe. The three curves show the behavior ST ESD CAN products and a competitor's device. Integrated circuits often use a 40 volt technology, having a higher over voltage may be risky. The ESD CAN 01 is the only device with a clamping voltage below 40 volts after 30 nanoseconds. This is 9 volts better than our competitor. The ESD CAN 01 has the lowest clamping voltage and is compatible with the 40 volt technology. The same tests have been done on the three products at 25 kilovolts, a much higher stress than the standard. In this case, the clamping voltage after 30 nanoseconds is higher than 40 volts and the difference between the three products is bigger. The ESD CAN 01 clamping voltage is 20 volts lower than the competitors. The ESD CAN 01 has the lowest clamping voltage. This is a comparison between the same competitor 01 and ST's old ESD CAN 24, showing a similar behavior when subjected to ISO 7637 Pulse 3. The curves are the same for both products. This confirms the TLP test. Both devices are similar. During the ISO 7637-2 Pulse 3a, the clamping voltage is also reduced by 8% from 31.2 to 28.7 volts. The ESD CAN 01 has the lowest clamping voltage. During the ISO 7637-2 Pulse 3b, the clamping voltage is also reduced by 3 volts. Again, the ESD CAN 01 has the lowest clamping voltage. Now, let's compare both ST devices. Both show a lower clamping voltage for ISO 7637 and 8x20 microsecond pulses for the new ESD CAN 01. For the same standoff voltage of 24 volts. If we compare our competitor 01 device with our ESD CAN 01, it becomes clear that the competitor considers its device as standard, with no automotive-specific consideration nor measurement. The only surge measurements are made with an 8x20 microsecond surge. Our ESD CAN 01-2 BLY is specified with an 8x20 microsecond surge, mainly for reference and comparison with competition, but also according to the ISO 7637 Pulse. This statement is also valid for the second competitor's device. The second competitor device is not rated according to ISO 7637-3. And besides, the clamping voltage for the same 8x20 microsecond surge is limited to 40 volts on the ESD CAN 01 versus 41 volts on the competitor device for the same standoff voltage. Most silicone component parameters are specified at 25 degrees Celsius, but in cars, the temperature can reach much higher levels, especially when located close to the engine. Data sheets from competitors include the power capability versus junction temperature curve. This curve starts from the power capability given in the previous page of the data sheet, generally at 25 degrees Celsius, and derates to 0 watts at high temperature. On the left curve, the first competitor gives the power capability at 25 Celsius degrees and derates to 0 at 150 degrees. On the middle curve, the second competitor gives the power capability at 0 degrees and derates to 0 at 150 degrees. ESD CAN 01-2 BLY power capability remains 230 watts up to 120 degrees and starts to derate to 200 watts at 150 degrees. ESD CAN 01-2 BLY demonstrates the best behavior at high temperature for use in harsh environments. On this slide, the previous curves are resized to get the same scale on the Y axis. Obviously, the second competitor in the middle gets the advantage at 0 degrees Celsius, but above 50 degrees, ST's ESD CAN 01-2 BLY has definitely the best surge capability. This page is a single slide summary for the ESD CAN 24 with the product key features and benefits we presented. This one is for the new version ESD CAN 01. Evidently, the difference between the two is at the clamping voltage level. To summarize, ESD CAN 01 is easy to use as it is rated with respect to the automotive standards and provides curves with clamping voltage according to ISO 7637-2 Pulse 3A and 3B. ESD CAN 01 provides a better protection of the CAN transceiver because the clamping voltage has been reduced versus the original ESD CAN 24 according to ISO 7637 surges and ISO 10605. ESD CAN 01 can be located in harsh environments because it maintains its surge capability of 230 watts up to 120 degrees Celsius. For more information, visit our website at www.st.com.esdcan01. Thank you for your attention.