Menu
Data modelling and management is important task when designing a database. Data governance is also required to ensure that data records are constraints and they are not duplicated or deleted without showing their impact on other tables. The presented report will discuss the database related requirement of a school that wants to manage the data regarding pupil, subjects and staff member. The report will present a use case diagram, entity relationship diagram, logical database design and simple queries the management can use on the database. Asides of this, the report will present comprehensive information regarding use case diagrams and entity relationship diagrams. It will discuss the used tools and techniques in database design and presents related evidence of output of queries.
Unified modelling language is used in system design and analysis to understand the system components and their behaviours. As a general modelling language, it helps to visualise the way in which system and its components can be designed and interconnected. It can be said that it is used to create blueprint of the system design. It indicates behaviour and structure of the system and it is not used for the programming (Aleryani, 2016). The main benefit of the unified modelling language is that it is easy to understand so that technical and non-technical users can easily understand the diagrams. It is used when target application is complex and there is need of planning and collaboration from multiple teams. This language and prepared diagrams helped to develop clear and concise way to communicate the features of the target system. It is also used to engage the nontechnical users during the system planning and designing so that their requirements can be addressed. It is also identified that the designing team can save significant amount of the time when they have visual diagrams for the system structure and behaviour so that they can effective code the modules for the system (Unhelkar, 2017). Unified modelling language diagrams can be classified mainly into two categories: structural diagram and behavioural diagram. Use case diagrams, sequence diagrams, state diagrams and interactive diagrams are part of the behavioural diagrams whereas class diagram, object diagram and component diagrams are part of the structural diagrams.
Use case diagrams are part of the unified modelling language diagrams and they are used to represent the behaviour of the system. Use case diagrams are useful to analyse and visualise the functionalities of a system while the system itself might be the part of a big system (Mishra and Arya, 2016). The presented figure shows the use case diagram for the school considered in the case study. This diagram is easy to understand for the senior management so that they can express their opinions for the further improvement and scope management. This diagram shows the various actors working on the system and how they are interacting with the system to meet their intended purposes. It is easy to understand that the new features and services can be added to the diagram without discarding the existing components. The stakeholders of the project such as school management can introduce an addition or removal of the component to control the project cost and features.
The presented use case diagram has several components and each component has some specific meaning for the system development team. Here is the description of the used components:
the diagram has one rectangle with the name of the system such as school database. It shows the system boundary. It means all the underlying actions are required to execute only on the school database solution and they are not related to the other systems to which the school database may be connected (Peng, 2019). For instance, the organisation is using the system as a part of the wider enterprise resource planning system then the actors and their interactions are limited only to perform the intended task with the defined system. System boundary is used by the system developers to understand the permission and access rights of the actors.
Actor is an individual or a group of the stakeholders who are connected to the system. These are the users who have direct or indirect interaction with the system to support the functionality (Jomartova and Zhumanov, 2022). For instance, there are mainly two human-actors in the case: staff and pupil. Staff is an actor in the diagram who has role to manage the subjects and pupils. Staff interacts with the system and can add, remove or update the subjects as per the requirements of the senior management. Similarly, staff can manage the pupil and their enrolment for the subjects. Second, pupil are actors who are receiving the data updated and managed by the staff. For instance, pupil can take subject if a particular subject is prepared by the staff member and added into the database. Similarly, they can manage their enrolment for a subject. The presented use case diagram has no integration of non-human actors. If the system design scope is expanded, non-human actors such as automatic chatbot and other features can be added to the system. However, such features are out of the scope for the presented case study and therefore, only human-actors are considered.
oval shapes within the system boundary indicates the use cases. A use case is an activity the user can perform with the system. In certain tasks, the use case may have dependency on other use cases for data. It is called as inclusion of the use cases. It is used to provide additional information to complete the operation. Similarly, one use case can be extended to other use cases to add more features to a task (Unhelkar, 2017).
it is a line between use case and actors. It is used to indicate which use case is related to which actor. It is used to avoid confusion when diagram is complex (Jomartova and Zhumanov, 2022). For example, ‘list the subject’ use case is associated to the staff whereas ‘take subject’ use case is associated to pupil. In certain cases, an association may exist among use cases. For instance, include is used when one use case is providing required information for other use case. Similarly, extend is used when one use case is extended for additional functionality. For example, ‘manage a subject’ can be extended to add or remove a subject.
In use case diagrams, packages are used to group the elements. It is used when working with a complex use case diagram and there are several activities that can be grouped according to their associations or can be connected to a single actor.
Figure 1: Use case diagram
As discussed, a use case diagram indicates the functionality of the system expected by the actors. One use case can be managed by one or more number of the actors. For example, there is a use case ‘take subject’. Staff also can assign a student to a subject while a student also can enrol in a subject. It means both of the actors can work on the use case. Asides of all these, the use case diagram is an overview of the system behaviour and it does not indicate how the coding for the application will be done in the background.
In database modelling and design, entity-relationship diagram has significant role. An entity-relationship diagram is a graphical representation that shows how the entities such as people, spaces, objects, events and concepts have association to each other under an information system (Aleryani, 2016). Therefore, entity-relation (ER) diagrams are used in data modelling to define the business processes and entities which are used later to create the relational database.
In database design, ER diagram provides a visual starting point to the database designers and developers. It is also useful even when the relational database is prepared because it can be used to debug the information system or re-engineer the system over the time to meet extended set of the requirements. It is important to note that, ER diagram is useful to represent the data modelling approach for a relational database. A relational database works on rows and columns and stores structural data (Weilbach et al., 2019). Opposite to this, non-structured or semi-structured data is hard to represent using ER diagram.
The presented ER diagram is depicted in one or more of the models used in data modelling. First, conceptual data model is generally used to provide an overview of the system so that it does not provide the specific details such as how data sets are used and interrelated. The entities of ER diagram serve this purpose as they do not show how the data is managed inside (Page and Six, 2017). Second, a logical data model provides more details in a comparison to the conceptual data model. It shows the details about the attributes and relationship among the data points. It is important to understand that a conceptual model is always prepared before the logical data model and then the logical data model becomes a starting point for the physical data model. ER diagram and its components such as attributes, entities and their relationships are part of the logical data model. In physical data model, a blueprint of the physical database is prepared for further implementation (Mohammed et al., 2015).
There are generally two formats in which ER diagram is prepared. For example, crow-foot notation is used to indicate the relationship between entities. Similarly, textual notations can be used to indicate a relationship. Here is the description of the components used in ER diagram:
As discussed earlier, an entity is a place, object, person or event that is storing data in the database. Rectangle shape is used to represent an entity (Al-Masree, 2015). For the presented ER diagram, it is easy to note that pupil, subject and staff are three entities.
In several ER diagrams when modelling a complex system, the diagram may have entity set. An entity set is a collection of similar types of the entities sharing the same set of properties. For example, the pupil and group of the pupil are same and they may share the same properties such as name, class and other things. Therefore, an entity set may be week or strong. A strong entity set has one primary key because one of the properties is sufficient to identify each entity uniquely (Letkowski, 2015). For example, the roll number of a pupil can be used to identify a pupil uniquely even when the pupil is part of the group or the part of pupils in the school. However, a weak entity lacks primary key and it has dependency on foreign key to identify each entity. Generally, weak entity is represented using double rectangle and they are avoided to make the data easily accessible in physical database design.
The characteristics of an entity are known as attribute. For example, staff has attributes such as staff ID, first name, surname, phone and address. Similar, attributes are associated to the pupil also. A subject entity has attributes such as subject code, description and subject name. An attribute in ER diagram may have several types (Al-Masree, 2015). For example, a single valued attribute contains only one value. For example, surname is an attribute of pupil and it contains only surname, not the first name and last name. Similarly, other attributes are of single-value attribute type. In certain diagrams, multivalued attribute is also used. Such attributes have one or more values that may be separated by a comma. For example, a phone number attribute may be multivalued as it can contain primary and secondary phone numbers of the staff.
Third, composite attributes are also used in some database designs. Composite attribute has one property: they can be further divided to make the data more accessible. For instance, an address attribute is a composite attribute and it can be divided into house number, street address, suburb, state, country and postal code. Similarly, a name attribute is a composite attribute as it can be divided into initial, first name, middle name and last name. Forth type of the attribute is derived attribute. For example, the school database is stored the age and date of birth. Here, age is derived as it has dependency on the date of birth attribute.
It is generally represented using a diamond shape. It shows the relationship between two or more entities. Following are major relationships in the given ER diagram:
it means one record in an entity exactly related to one record in another entity. Suppose, there is a database that contains drivers and buses. In such cases, one driver can drive only one bus and therefore, there will be one-to-one relationship. In the presented ER diagram, there is no such example of one-to-one relationship. Such kind of relationship may have mandatory or optional values (Letkowski, 2015). For example, one country must have one currency. It shows mandatory relationship. In optional relationship, one entity may not have relationship with records in other entity. For example, a person may have only one fingerprint but the database may not have any registered fingerprint for a person. In this case, the person will have optional one-to-one relationship.
it means that one or more number of records in an entity may have association to the one record in another entity. For example, pupil and subject has many-to-one relationship because one subject can be taken by one or many numbers of the pupils in the school. Alternatively, it can be said that many pupils can take one subject. If it is optional that a pupil can select one or many subjects, then there will be optional many-to-one relationship between pupil and subject. Similar relationship exists between pupil and staff. One or many numbers of pupils can be managed by one staff. However, it is not true that there are many staff members managing one pupil.
it means that many records of an entity has relationship with many numbers of records in another entity (Peng, 2019). For example, staff and subject entity has this relationship. One staff member can manage or handle one or more subjects. Similarly, one subject may be managed or taught by one or more number of staff members.
Figure 2: Entity relationship diagram
Logical design is generally the ending task delivered by the database designer. It shows how the database is logically designed to store the data. Once the database is designed, the resources can use the database to insert the values. There are several professional tools and database systems can be used to manage the data. The preferred solution for the organisation is to use structured database while using a graphical user interface to create tables, manage data and execute the queries. Following are two major tools used during logical design:
it is a solution stack developed for windows to run the web applications without working directly on the hosting platforms. It helps the developers to work with database and web design so that they can easily prepare the final solution and connect the solution to the hosting environment. Wamp means to Windows, Apache, MySQL and PHP. It indicates that the solutions are purely designed to work on Windows machines. Apache is a popular open-source web server which is used to run server-side scripting code (Techterms.com, 2023). MySQL is a relational database management system. PHP is a programming language for the web application and it is an acronym for pre-processed hypertext.
it is part of the Wamp-server but it can be installed and executed separately. MySQL is an open-source relational database solution which means that it can manage the larger set od structured data. It is developed by Oracle and it supports SQL-like commands to accomplish the tasks. It is easy to use due to its rigid storage structure. It stores the data in a tabular form which is easy to understand and manage. It also supports a wide range of inputs such as numbers, date and time and alphanumeric values (Letkowski, 2015). One of the notable things about MySQL is that it is highly compatible with most of the systems to achieve easier functionality. It can be integrated with other tools to work on database.
Wamp and other similar server tools allows to manage database using graphical user interface where the most of command-like task can be simplified. For instance, this database is prepared using phpMyAdmin tool which is available within Wamp. Following are more details regarding how the professional tools are used to create database and tables.
In MySQL, table cannot be created without creating database because MySQL manages the data using databases that are files storing the data. Therefore, it is important to create a database. Let the name of the database as ‘school’. When phpMyAdmin is opened, it will ask for the username and password. By default, username is root. There is no password set at beginning so user can leave the field empty.
Figure 3: Creating database using phpMyAdmin
Once database is created, it will ask to enter the name of the table and number of columns in the table. Considering ER diagram, following three tables and their attributes are required:
This table is required to record the data regarding staff members. Following are major attributes/ column of the table:
StaffID: it is a primary key for the table. It means that it can be used to access each record of the table uniquely. This field cannot be null or duplicate. There is no information given regarding the size of the field so that it can be assumed to have maximum five digits while it is of integer type.
Firstname: it is used to store the first name of the staff. It is assumed that first name may have maximum 50 characters and it cannot be empty. However, two or more staff members may have same first name.
Surname: it is used to store the surname of the staff. The combination of first name and surname will help to retrieve the complete name of the staff member. It is also assumed to have maximum 50 characters. Both fields are of text type.
This table is used to store data regarding pupil. Following are major attributes/ column of the table:
studentID: each student has unique identification number which cannot be duplicated and leaved empty during data insertion. Therefore, it is a primary key to access each record effectively. It can be assumed to have maximum five digits while it is of integer type.
of integer type.
Firstname: it is used to store the first name of the pupil. It is assumed that first name may have maximum 50 characters and it cannot be empty. However, two or more pupil may have same first name.
Surname: it is used to store the surname of the pupil. The combination of first name and surname will help to retrieve the complete name of the pupil. It is also assumed to have maximum 50 characters. Both fields are of text type.
Address: this field contains the address of the pupil’s residence or current living location. As discussed earlier, address is a composite attribute so it has house number, street, landmark, city, state and country. Therefore, this field can be further divided into atomic attributes under the normalisation process. Address contains house number and other textual data and it may contain alphabets as well as numbers. Text type is an appropriate type for the field. The field can be limited to have maximum 255 characters.
Postal-code: this field is used to store the postal code of the address. As postal code is a numeric value so that the field is of integer type. It is not constrained to the size but maximum digits in a postal code are five in most of the countries.
Staff ID: this field is added to the pupil table because there is a staff who is managing the pupil. It can be considered as a class teacher for the student. It is a foreign field and therefore, it must have type and size as declared in its main table. Therefore, it is of number type and it can contain five digits.
This table contains data related to subjects that are available to the pupils. Following are major attributes/ column of the table:
Subject-code: each subject has unique identification number and that number can be used to fetch the details of the subject. It is assumed that subject code is of size 5 digits while it is an integer or number value. This attribute cannot be null or duplicate.
Subject-name: each subject has a name but name of two subjects that might be taught in different classes may have same name. For example, there might be two subjects with name ‘mathematics’ but having different subject-code because they are taught in different classes or have meaning such as core mathematics and advance mathematics. Therefore, this field is not unique. It contains textual value so it is limited to have maximum 100 characters.
Pupil ID: it is a foreign field for the table. It is used to map the pupil and subject taken by the pupil. However, it is worth to note that one subject may be taken by one or many students, there will be need to create new tables to meet the overall data storage requirements.
This table is created to store the data about pupil and subject taken by them. This table is used to map the relationship between pupil and subject table. It has two attributes:
Subject-code: each subject has unique identification number and that number can be used to fetch the details of the subject. It is foreign key here so it has number type and can contains maximum five digits.
Pupil-ID: it is a foreign key to pupil table. It is foreign key here so it has number type and can contains maximum five digits.
Figure 4: Pupil table
Figure 5: Staff table
Figure 6: Subject table
Figure 7: Subject-taken table
Figure 8: Data in pupil table
Figure 9: Data in staff table
Figure 10: Data in subject table
Figure 11: Data in subject-taken table
-- phpMyAdmin SQL Dump
-- version 5.2.0
-- https://www.phpmyadmin.net/
--
-- Host: 127.0.0.1:3306
-- Generation Time: Mar 14, 2023 at 10:45 AM
-- Server version: 8.0.31
-- PHP Version: 8.0.26
SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
START TRANSACTION;
SET time_zone = "+00:00";
/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8mb4 */;
--
-- Database: `school`
--
-- --------------------------------------------------------
--
-- Table structure for table `pupil`
--
DROP TABLE IF EXISTS `pupil`;
CREATE TABLE IF NOT EXISTS `pupil` (
`studentID` int NOT NULL,
`firstname` text NOT NULL,
`surname` text NOT NULL,
`address` text NOT NULL,
`postalCode` int NOT NULL,
`staffID` int NOT NULL,
PRIMARY KEY (`studentID`),
KEY `staffID` (`staffID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
--
-- Dumping data for table `pupil`
--
INSERT INTO `pupil` (`studentID`, `firstname`, `surname`, `address`, `postalCode`, `staffID`) VALUES
(221, 'Lucy', 'Anderson', '78, B street, NY', 12131, 111),
(222, 'Kiara', 'Johnson', '23, B-Block, Near J Hospital, Wallstreet', 12345, 112),
(223, 'William', 'Shawn', 'Near K-school, NY', 12131, 111);
-- --------------------------------------------------------
--
-- Table structure for table `staff`
--
DROP TABLE IF EXISTS `staff`;
CREATE TABLE IF NOT EXISTS `staff` (
`staffID` int NOT NULL,
`firstname` text NOT NULL,
`surname` text NOT NULL,
PRIMARY KEY (`staffID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
--
-- Dumping data for table `staff`
--
INSERT INTO `staff` (`staffID`, `firstname`, `surname`) VALUES
(111, 'John', 'Peter'),
(112, 'George', 'Gray'),
(113, 'George', 'Brown');
-- --------------------------------------------------------
--
-- Table structure for table `subject`
--
DROP TABLE IF EXISTS `subject`;
CREATE TABLE IF NOT EXISTS `subject` (
`subjectCode` int NOT NULL,
`subjectName` text NOT NULL,
PRIMARY KEY (`subjectCode`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
--
-- Dumping data for table `subject`
--
INSERT INTO `subject` (`subjectCode`, `subjectName`) VALUES
(551, 'Mathematics'),
(552, 'Mathematics'),
(553, 'Science'),
(554, 'Social science');
-- --------------------------------------------------------
--
-- Table structure for table `subject_taken`
--
DROP TABLE IF EXISTS `subject_taken`;
CREATE TABLE IF NOT EXISTS `subject_taken` (
`subjectCode` int NOT NULL,
`studentID` int NOT NULL,
KEY `subjectCode` (`subjectCode`),
KEY `studentID` (`studentID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
--
-- Dumping data for table `subject_taken`
--
INSERT INTO `subject_taken` (`subjectCode`, `studentID`) VALUES
(551, 222),
(551, 221),
(552, 223),
(554, 222);
--
-- Constraints for dumped tables
--
--
-- Constraints for table `pupil`
--
ALTER TABLE `pupil`
ADD CONSTRAINT `pupil_ibfk_1` FOREIGN KEY (`staffID`) REFERENCES `staff` (`staffID`);
--
-- Constraints for table `subject_taken`
--
ALTER TABLE `subject_taken`
ADD CONSTRAINT `subject_taken_ibfk_1` FOREIGN KEY (`subjectCode`) REFERENCES `subject` (`subjectCode`),
ADD CONSTRAINT `subject_taken_ibfk_2` FOREIGN KEY (`studentID`) REFERENCES `pupil` (`studentID`);
COMMIT;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
Queries can be executed on the above database to obtain the relevant information. Following are major queries executed.
Query 1: Find all the students who are managed by staff having identification number as 111.
In the above query, we are finding all the students who are managed by a staff having identification number as 111. It means, the output should not contain any record of the students who are managed by other staff. Therefore, there is use of WHERE clause to compare the staff ID to a particular value. As the results indicate, there are two records in which staff ID is same as required.
This query can help the organisation to identify the students who are assigned to a staff for a particular reason.
Query 2: Print staff name that are unique (avoid staff having same first name)
SELECT staff.staffID, staff.firstname, staff.surname, COUNT(*) FROM staff GROUP BY staff.firstname HAVING COUNT(*)=1;
In the above query, we are finding the staff members who are not having the same name. For example, two staff may have same first name such as George. In such cases, the query can help to avoid the staff members having George as their first name. Here COUNT is used to count the number of the records in staff table whereas GROUP BY is used to group the records using first name field in the table (Christudas and Christudas, 2019). Also, HAVING is used to identify whether the COUNT of the records is equal to 1. Note that, COUNT (*) is 1 when there is no the grouping of first name has only one record. If there are more count of first name then COUNT (*) will delivery 2 or more as output.
This query is useful when the organisation is trying to find the unique first names from staff to find some staff member’s details quickly. The opposite of the query is also useful if there is a need to find the staff with same name but management wants to know their staff ID or surname.
Query 3: Count the number of subjects taken by a student
SELECT pupil.firstname, pupil.surname, COUNT(subject_taken.subjectCode) AS Subjects_taken FROM pupil, subject_taken WHERE subject_taken.studentID=pupil.studentID GROUP BY subject_taken.studentID;
The above query works on two tables pupil and subject-taken. Pupil table is used to show first name and last name of the pupil instead to show their student ID so that the record is easier to read and understand. Subject-taken table is used to count the subjects. Also, WHERE clause is used to show the first name and last name if particular student ID of subject-take table exists in pupil’s student ID column. GROUP BY is important to use because without this, the records will not be grouped and counting will be wrong.
This query is useful when the organisation wants to identify the number of subjects taken by each student. If it is not used, there will be need to count each record separately from the table and it is a lengthy and erroneous task, especially when there are thousands of records.
Query 4: Count the number of students who have taken a subject.
SELECT subject_taken.subjectCode, COUNT(subject_taken.studentID) AS count_of_students FROM subject_taken GROUP BY subject_taken.studentID;
The above query is used to indicate the number of students who have taken a same subject. Here, COUNT is used to count the students and it is renamed to count_of_student using AS keyword. GROUP BY is used to group the output by student ID.
This query is useful when staff is trying to find the popularity of the subject. Suppose, there is need to discontinue the subject if it is taken only by one student then such query is useful to find the records.
Query 5: find details of all distinct staff members who are assigned to the students.
SELECT DISTINCT(staff.staffID), staff.firstname, staff.surname FROM staff, pupil WHERE staff.staffID=pupil.staffID;
The above query uses DISTINCT keyword to find the distinct records. There is use of two tables to print first name and surname of the staff. It is possible that one staff may be assigned to many students. In such cases, the query shows only distinct staff ID so that management can identify all used staff ID in pupil table.
The report has concluded that the data modelling can be done effectively using use case diagrams and other diagrams in unified modelling language. It has presented use case diagram and entity relationship diagram and created a logical database. The report has presented comprehensive discussion of the diagrams and assumptions while discussed the importance of the various queries. It has presented output of the queries also.
Aleryani, A.Y., 2016. Comparative study between data flow diagram and use case diagram. International Journal of Scientific and Research Publications, 6(3), pp.124-126.
Al-Masree, H.K., 2015. Extracting Entity Relationship Diagram (ERD) from relational database schema. International Journal of Database Theory and Application, 8(3), pp.15-26.
Christudas, B. and Christudas, B., 2019. MySQL (pp. 877-884). Apress.
Jomartova, S. and Zhumanov, Z., 2022. Fundamentals of UML. Educational manual. Litres.
Letkowski, J., 2015. Doing database design with MySQL. Journal of Technology Research, 6, p.1.
Letkowski, J., 2015. Doing database design with MySQL. Journal of Technology Research, 6, p.1.
Mishra, A. and Arya, S., 2016. Role of UML in Object Oriented Design. International Journal for Research and Development In Technology, 6(3), pp.2349-3585.
Mohammed, M.A., Abdul, D., Muhammed, K. and Abdullah, J.M., 2015. Practical Approaches of Transforming ER Diagram into Tables. International Journal of Multidisciplinary and Scientific Emerging Research, 4(22), pp.2349-6037.
Page, C. and Six, H.W., 2017. Software engineering. Larsen and Keller Education.
Peng, Y., 2019. Overview of Object-Oriented System Development Method and UML Modeling.
Phillips, G., 2018. How to use Wamp server. Retrieved from: https://www.makeuseof.com/tag/how-to-set-up-your-own-wampserver/. Accessed on: 13 March 2023.
Techterms.com, 2023. WAMP. Retrieved from: https://techterms.com/definition/wamp. Accessed on: 13 March 2023.
Unhelkar, B., 2017. Software engineering with uml. CRC Press.
Weilbach, L., Hattingh, M. and Pillay, K., 2021. Using Design Patterns to Teach Conceptual Entity Relationship (ER) Data Modelling. In Innovative Technologies and Learning: 4th International Conference, ICITL 2021, Virtual Event, November 29–December 1, 2021, Proceedings 4 (pp. 228-238). Springer International Publishing.
You May Also Like:
Computer Science Dissertation Ideas
Tailored Pc Models and Servers by Made to Measure Computers Assessment Answer
1,212,718Orders
4.9/5Rating
5,063Experts
Turnitin Report
$10.00Proofreading and Editing
$9.00Per PageConsultation with Expert
$35.00Per HourLive Session 1-on-1
$40.00Per 30 min.Quality Check
$25.00Total
FreeGet
500 Words Free
on your assignment today
Request Callback
Doing your Assignment with our resources is simple, take Expert assistance to ensure HD Grades. Here you Go....
🚨Don't Leave Empty-Handed!🚨
Snag a Sweet 70% OFF on Your Assignments! 📚💡
Grab it while it's hot!🔥
Claim Your DiscountHurry, Offer Expires Soon 🚀🚀
+61 435 881 621
+61 435 881 621