Course & Code: Library and Web Tecnology
LEVEL : LIS
Semester: Autumn 2023
Assignment No. 01
SYED IHTISHAM UL HASSAN SHAH
20PLR04625
Name.
[Link] library and information science
User id.
[Link] 2023
Code book.9213.
Assignment No. 1
Q1. Define database-backed web pages. Also compare among the old-
fashioned way’, creating static web page’, and ‘creating dynamic web
page’ with examples.
Answer.
Define database-backed web pages.
Database-backed web pages refer to web pages that dynamically
generate content by retrieving and displaying data from a database.
Instead of presenting static information, these pages use server-side
programming languages, such as PHP, Python, or Ruby, to interact with
a database. This allows for real-time updates and the ability to handle
dynamic content, such as user-generated input or changing information.
The database stores and manages the data, while the web server
retrieves and processes it to generate the content presented on the
web page.
Compare among the old-fashioned way’, creating static web page’, and
‘creating dynamic web page’ with examples.
Static Web pages: Static Web pages are very simple. It is written in
languages such as HTML, JavaScript, CSS, etc. For static web pages when
a server receives a request for a web page, then the server sends the
response to the client without doing any additional process. And these
web pages are seen through a web browser. In static web pages, Pages
will remain the same until someone changes it manually.
The "old-fashioned way” of creating static web pages refers to the
traditional method where web pages are built using only HTML and CSS,
without dynamic or interactive elements.
In static web pages, Pages will remain same until someone changes it
manually.
Static Web Pages are simple in terms of complexity.
Information are change rarely.
Static Web PageTakes less time
For loading than dynamic web page.
Dynamic Web Pages: Dynamic Web Pages are written in languages such
as CGI, AJAX, ASP, [Link], etc. In dynamic web pages, the Content of
pages is different for different visitors. It takes more time to load than
the static web page. Dynamic web pages are used where the
information is changed frequently, for example, stock prices, weather
information, etc.
In dynamic web pages, Content of pages are different for different
visitors.
2. Static Web Pages are simple in terms of complexity.
Dynamic web pages are complicated.
3. In static web pages, Information are change rarely. In dynamic
web page, Information are change frequently.
4. Static Web Page takes less time for loading than dynamic web
page.
Dynamic web page takes more time for loading.
5. In Static Web Pages, database is not used.
In dynamic web pages, database is used.
6. Static web pages are written in languages such as: HTML,
JavaScript, CSS, etc.
Dynamic web pages are written in languages such as: CGI, AJAX,
ASP, [Link], etc.
7. Static web pages does not contain any application program
. Dynamic web pages contains application program for different
services.
8. Static web pages require less work and cost in designing them.
Dynamic web pages require comparatively more work and cost in
designing them.
Let’s compare this approach with modern methods using examples:
Old-Fashioned Way (Static Web Pages):
1. HTML Structure:
Example HTML:
Html
<!DOCTYPE html>
<html>
<head>
<title>Static Page</title>
</head>
<body>
<h1>Welcome to my website</h1>
<p>This is a static web page.</p>
</body>
</html>
Explanation: HTML provides the structure of the page, defining
headings, paragraphs, and other elements.
2. CSS Styling:
Example CSS:
Css
Body {
Background-color: #f0f0f0;
Font-family: Arial, sans-serif;
}
H1 {
Color: #333;
}
P{
Color: #666;
}
Explanation: CSS is used for styling, setting colors, fonts, and layout
properties.
3. Interactivity:
No JavaScript or server-side scripting for dynamic features.
User interactions are limited to basic links and forms.
4. Deployment:
Hosting involves uploading HTML and CSS files to a web server.
Updates require manual changes to files.
Modern Approach (Dynamic Web Pages):
1. HTML Structure with Frameworks:
Example using React (JavaScript library):
Jsx
Import React from ‘react’;
Function DynamicPage() {
Return (
<div>
<h1>Welcome to my website</h1>
<p>This is a dynamic web page built with React.</p>
</div>
);
}
Export default Dynamic Page;
Explanation: Frameworks like React allow the creation of reusable
components, enhancing code organization.
2. Enhanced Styling:
Example using styled-components in React:
Jsx
Import styled from ‘styled-components’;
ConstStyled = [Link]`
Background-color: #f0f0f0;
Font-family: Arial, sans-serif;
`;
ConstStyled Heading = styled.h1`
Color: #333;
`;
ConstStyled Paragraph = styled.p`
Color: #666;
`;
Explanation: Modern styling approaches like CSS-in-JS provide
enhanced modularity and scope.
3. Interactivity with JavaScript:
Example using React state:
Jsx
Import React, { useState } from ‘react’;
Function InteractivePage() {
Const [count, setCount] = useState(0);
Return (
<div>
<p>Count: {count}</p>
<button onClick={() =>setCount(count + 1)}>Increment</button>
</div>
);
}
Export default Interactive Page;
Explanation: JavaScript enables dynamic content, user interactions, and
real-time updates.
4. Deployment and Updates:
Continuous integration tools, automatic deployment pipelines, and
version control systems streamline the deployment process.
Updates are more efficient through tools like Git and automated build
processes.
In summary, the old-fashioned way involves static HTML and CSS for
basic web pages, while the modern approach incorporates dynamic
elements, enhanced styling methods, and efficient deployment
processes using frameworks and libraries.
Compare among the creating dynamic web page’ with examples.
Creating dynamic web pages involves using technologies like HTML, CSS,
and JavaScript to produce interactive and responsive content. Let’s
break down the components and provide examples:
HTML (Hypertext Markup Language):
Static Content: Traditional HTML provides the structure and static
content of a webpage.
Html
<!DOCTYPE html>
<html>
<head>
<title>Static Webpage</title>
</head>
<body>
<h1>Hello, World!</h1>
</body>
</html>
CSS (Cascading Style Sheets):
Styling: CSS is used to style the static content, defining colors, fonts,
layout, etc.
Css
Body {
Background-color: #f0f0f0;
Font-family: Arial, sans-serif;
}
H1 {
Color: #333;
}
JavaScript:
Dynamic Behavior: JavaScript adds interactivity and dynamic behavior
to web pages.
Html
<script>
Function greetUser() {
VaruserName = prompt(“Enter your name:”);
Alert(“Hello, “ + userName + “!”);
}
</script>
Dynamic Content with JavaScript:
Manipulating HTML: JavaScript can dynamically manipulate the DOM
(Document Object Model), changing content on the fly.
Html
<button onclick=”greetUser()”>Say Hello</button>
Fetching Data: JavaScript can make AJAX (Asynchronous JavaScript and
XML) requests to fetch data from a server.
Javascript
// Using Fetch API
Fetch(‘[Link]
.then(response =>[Link]())
.then(data =>[Link](data))
.catch(error =>[Link](‘Error:’, error));
Frameworks and Libraries:
React Example: Libraries and frameworks like React provide a more
structured way to build dynamic web application
// React Component
Function Greeting() {
Const [name, setName] = [Link](‘’);
ConsthandleChange = (event) => {
setName([Link]);
};
Return (
<div>
<input type=”text” onChange={handleChange} />
<p>Hello, {name}!</p>
</div>
);
}
In summary, creating dynamic web pages involves using HTML for
structure, CSS for styling, and JavaScript for adding interactivity and
dynamic content. Libraries and frameworks like React further
streamline the development process, providing efficient ways to
manage state and build complex user interfaces
Q2. Discuss various database management approaches with relevant
examples.
Answer.
Database management approaches can be broadly categorized into
several models, each with its own advantages and use cases.
Here are some of the main approaches:
Hierarchical Model:
Description: Data is organized in a tree-like structure, with a single root
and branches emanating from the root. Each node can have multiple
children, creating a parent-child relationship.
Example: IMS (Information Management System) is an example of a
database management system that follows the hierarchical model.
Network Model:
Description: Similar to the hierarchical model, but allows more complex
relationships. Records can have multiple parent and child records,
forming a network-like structure.
Example: CODASYL DBTG (Conference on Data Systems Languages
Database Task Group) databases follow the network model.
Relational Model:
Description: Data is organized into tables with rows and columns.
Relationships between tables are established using keys. It provides a
flexible and powerful way to organize and retrieve data.
Example: MySQL, PostgreSQL, and Oracle Database are popular
relational database management systems (RDBMS) that follow the
relational model.
Object-Oriented Model:
Description: Extends the relational model to include objects, classes,
and methods. It is particularly useful for representing complex
relationships and modeling real-world entities.
Example: Object-oriented databases like db4o and ObjectDB follow this
model.
Document Store Model:
Description: Stores and retrieves data in the form of documents,
typically in JSON or XML format. Each document can have nested
structures and is identified by a unique key.
Example: MongoDB is a popular NoSQL database that follows the
document store model.
Graph Model:
Description: Represents data as a graph with nodes, edges, and
properties. This model is suitable for data with complex relationships,
such as social networks or network infrastructure.
Example: Neo4j is a graph database management system that follows
the graph model.
Columnar Store Model:
Description: Organizes data by columns rather than rows, which can
improve query performance for certain types of analytical queries.
Example: Apache Cassandra is a NoSQL database that uses a columnar
store model.
Time-Series Model:
Description: Optimized for handling time-stamped data points, such as
measurements, events, or logs.
Example: InfluxDB and OpenTSDB are examples of time-series
databases.
In-Memory Model:
Description: Data is stored in the computer’s main memory (RAM) for
faster access compared to traditional disk-based databases.
Example: SAP HANA and Redis are examples of in-memory database
systems.
Cloud-Based Model:
Description: Database services provided through cloud platforms,
offering scalability, flexibility, and managed services.
Example: Amazon Aurora, Microsoft Azure SQL Database, and Google
Cloud Firestore are examples of cloud-based database solutions.
These models cater to different requirements and scenarios, and the
choice depends on factors such as data complexity, scalability, and
performance needs.
Q3. Discuss basic concepts coding in programming with examples.
Answer.
The process of coding involves creating instructions to direct the
computer to perform a specific task. All software programs adhere to
certain coding principles and concepts. A basic understanding of various
coding concepts may be beneficial if you’re new to coding or if you want
to improve your coding skills. In this article, we discuss some
fundamental coding concepts along with their definitions and examples
and offer some tips for improving your coding skills.
What are fundamental coding concepts?
Fundamental coding concepts include a set of basic principles and
related terminologies that programmers can follow to write code that is
simple to understand, modular, and efficient. The basic coding concepts
include variable declaration, basic control structures, data structures,
object-oriented programming, troubleshooting and debugging, and
various programming tools. These concepts are similar across different
programming languages, such as C, C++, Python, and Java.
The following are six basic coding concepts:
1. Variable declaration
Variables are containers for storing values. You can declare variables
using variable names. Declaring a variable instructs the operating
system to reserve a piece of memory with that variable name. You can
define a variable with letters, digits, and underscores.
Variables store standard data types, such as:
Number: Numbers store numerical values. The various numerical types
include int, long, float, and complex used to store signed integers, long
integers, floating-point real values, and complex numbers, respectively.
String: Strings store a set of characters enclosed either by single or
double quotes.
List: Lists can store multiple items, such as integers, floats, strings, or
other lists, in a single variable. The items stored in a list are changeable,
ordered, and accessible via indexes.
Tuple: Tuples can store multiple items, such as integers, floats, strings,
or other lists, in a single variable. The items stored in a tuple are
unchangeable, ordered, and accessible via indexes.
Dictionary: Dictionaries store key-value pairs. The items stored in a
tuple are unordered, unchangeable, and accessible using a key.
2. Control structures
A control structure specifies the flow of control in a program. Analyzing
certain parameters and conditions determines the flow direction of a
program. Control structures make it easier to understand a flow of logic
when developing algorithms or writing programs.
There are three basic types of control structures:
Sequential logic: The flow of a program executes in a specific order
without skipping, jumping, or switching to another block of code.
Selection logic: A condition determines whether a block of code gets
executed or skipped. Common examples include if and else-if.
Iteration logic: A block of code repeats a fixed number of times to
achieve the desired result. Common examples include for and while
loop.
Related: What Is For Loop and Why Is It Important In Coding?
3. Data structures
A data structure provides an effective way to store and retrieve data.
There are various data structures that computer programmers can use
to complete tasks and run applications.
These are some commonly used data structures:
Arrays: Arrays organize data by storing similar elements together and
using contiguous memory allocation. You can use arrays to store an
ordered list of items.
Stacks: Stacks are linear structures that follow a last-in, first-out (LIFO)
order for executing operations. You can use stacks to store data that get
processed in a specific order.
Queues: The queue is a linear structure that follows a first-in, first-out
(FIFO) order for executing operations. You can use queues to store data
that don’t require immediate processing.
Linked lists: Linked lists are linear data structures that use pointers to
link elements instead of contiguous memory locations. You can use
them to implement stacks, queues, and graphs.
Binary trees: Binary trees are non-linear structures containing nodes
that have two possible values or directions. You can use binary trees to
represent hierarchy and determine structural relationships in data.
Graphs: Graphs contain nodes and edges connected to one another.
You can use these data structures to study maps, resource allocation in
operating systems, and social media networks.
Hash-tables: Hash-tables, also known as maps, store key-value pairs.
You can retrieve the value in the hash table by specifying its key where a
key can store multiple values.
4. Object-oriented programming
Object-oriented programming is based on the concept of objects and
classes where an object may contain data in the form of attributes and
methods. Classes are user-defined blueprints or prototypes from which
you can create objects. For example, consider a class that represents a
car. The car class contains attributes such as colour, date of
manufacture, weight, and mileage. You can then use this class as a
blueprint to create objects where each object represents a different car
with a unique set of attributes.
Some important concepts in object-oriented programming include:
Encapsulation: Encapsulation is the binding of data elements, such as
variables and properties and member methods, into one unit.
Abstraction: Abstraction enables you to hide specific details about a
class and provide only essential information to the outside world. You
can use the ‘abstract’ keyword to declare an abstract class.
Inheritance: Inheritance enables you to create a new class from an
existing class. For example, you can create many child classes which
inherit all the properties of their parent classes and have their own set
of additional attributes and methods.
Polymorphism: Using polymorphism, you can access objects of
different types using the same interface where each object provides its
own implementation.
Related: 12 Top Jobs in Coding (With Relevant Industry Skills)
5. Debugging
Debugging is the process of removing errors from computer programs.
The process allows software development and engineering teams to
ensure that the software works as intended. You can encounter various
coding errors throughout the development phase. Below is a list of
possible errors:
Syntax error
Syntax errors arise when characters or tokens in the code don’t follow
the syntax of the programming language. These errors can be due to
indentation errors, missing brackets, extra commas, or misspelled
commands. An IDE detects such errors and displays the line number,
error type, and description along with the error. After reviewing the
error description, you can modify the code to follow the correct syntax.
Runtime errors
A runtime error occurs when there is a flaw in the algorithm or logic of
the code. This results in the program producing unexpected results. You
encounter logical errors only during runtime since there are no errors in
the code’s syntax, which results in a successful compilation. For
instance, wrongly initializing a variable can cause a logical error in the
code.
Latent errors
Latent errors, also known as hidden errors, arise when you use a
specific set of data as input to the program. A program can fail or
produce incorrect results if you fail to account for an outlier or edge
case. You may have created a program that prompts users to enter their
dates of birth but does not account for characters or negative numbers
they may enter incorrectly. This could cause the program to crash or
halt.
Let’s cover some fundamental concepts in programming:
Variables:
Variables store data in a program. They have a name and a value.
Example:
Python
Age = 25
Name = “John”
Data Types:
Different types represent different kinds of data (e.g., integers, strings,
floats).
Example:
Java
Int number = 42;
String text = “Hello, World!”;
Control Flow:
Decision-making using conditionals (if-else statements).
Example:
Python
If age >= 18:
Print(“You are an adult.”)
Else:
Print(“You are a minor.”)
Loops:
Repeating a set of instructions using loops (for, while).
Example:
JavaScript
For (let I = 0; I < 5; i++) {
[Link](i);
}
Functions:
Blocks of reusable code, taking inputs and producing outputs.
Example:
Python
Def greet(name):
Return “Hello, “ + name + “!”
Arrays/Lists:
Ordered collections of items.
Example:
Java
Int[] numbers = {1, 2, 3, 4, 5};
Objects/Classes:
Grouping variables and functions into a single unit.
Example:
Javascript
Class Car {
Constructor(make, model) {
[Link] = make;
[Link] = model;
}
}
Comments:
Annotations within code for better understanding.
Example:
Python
# This is a single-line comment
“””
This is aMulti-line comment
“””
Error Handling:
Dealing with unexpected situations.
Example:
Python
Try:
Result = 10 / 0
Except Zero Division Error:
Print(“Cannot divide by zero!”)
Recursion:
A function calling itself.
Example:
Java
Int factorial(into n) {
If (n == 0 || n == 1)
Return 1;
Else
Return n * factorial(n – 1);
}
These concepts provide a foundation for programming in various
languages. Each programming language may have its syntax, but these
fundamental ideas remain consistent across most languages
Q4. How to design a database project? Discuss the major components
in project design.
Answer.
Designing a database project involves several key steps:
Define Requirements:
Understand the purpose and goals of the database.
Identify entities, attributes, and relationships.
Conceptual Design:
Create an Entity-Relationship Diagram (ERD) to represent entities
and relationships.
Normalize data to reduce redundancy.
Logical Design:
Translate the ERD into tables with defined data types and
relationships.
Normalize tables to optimize data structure.
Normalization:
Apply normalization techniques to minimize data redundancy and
dependency.
Data Integrity:
Enforce constraints (primary keys, foreign keys) for data integrity.
Consider triggers and stored procedures for complex rules.
Physical Design:
Decide on storage structures, indexing, and partitioning for
performance.
Consider hardware and software constraints.
Security:
Implement access controls and permissions.
Encrypt sensitive data.
Data Migration:
Plan and execute the migration of existing data into the new database.
Testing:
Test the database design for data accuracy, performance, and security.
Documentation:
Create comprehensive documentation for the database schema,
relationships, and procedures.
Optimization:
Continuously monitor and optimize the database for performance.
Backup and Recovery:
Establish regular backup and recovery procedures.
Scalability:
Design the database to scale as data volume increases.
Maintenance:
Develop a maintenance plan for routine tasks like updates, backups,
and performance tuning.
User Training:
Train users and provide documentation on how to interact with the
database.
Remember, each project is unique, and adjustments may be needed
based on specific requirements and constraints. Regularly collaborate
with stakeholders and adapt the design as needed throughout the
development process.
Discuss the major components in project design.
Project design typically involves several key components:
Project Objectives: Clearly define the goals and outcomes the project
aims to achieve. These should be specific, measurable, achievable,
relevant, and time-bound (SMART).
Scope: Outline the boundaries of the project, specifying what is
included and excluded. This helps manage expectations and prevents
scope creep.
Stakeholder Identification: Identify and involve all relevant
stakeholders, including project sponsors, team members, and end-
users. Understand their interests and expectations.
Project Deliverables: Define the tangible outputs or results the project
will produce. These can be products, services, or other measurable
outcomes.
Timeline: Develop a realistic project schedule with milestones and
deadlines. Consider dependencies between tasks and allocate resources
appropriately.
Resource Planning: Identify and allocate the necessary resources,
including human resources, equipment, materials, and budget. Ensure
that the resources align with the project requirements.
Risk Assessment: Identify potential risks that could impact the project
and develop strategies to mitigate or respond to them. This includes
assessing both internal and external factors.
Quality Standards: Establish criteria for measuring the quality of project
deliverables. This ensures that the project meets predefined standards
and satisfies stakeholder expectations.
Communication Plan: Outline how information will be shared among
team members and stakeholders. Define communication channels,
frequency, and methods.
Monitoring and Evaluation: Implement a system to track progress,
assess performance, and measure outcomes against the project
objectives. This allows for adjustments and improvements as needed.
Documentation: Maintain thorough documentation throughout the
project lifecycle. This includes project plans, meeting minutes, change
requests, and any other relevant records.
Closure and Evaluation: Develop a plan for closing out the project,
including finalizing deliverables, obtaining stakeholder feedback, and
conducting a project review to identify lessons learned.
Effective project design considers these components holistically,
promoting a structured approach to planning and execution.
Q5. Write short notes on the following:
a. Database administration tools
b. Arbitrary vs. Descriptive Keys
C. Structured Query Language (SQL)
d. integrity and Security
e .LCSH (Library of Congress Subject Heading)
Answer.
A .Database Administration Tools:
Definition: Database administration tools are software applications that
assist database administrators in managing and maintaining relational
database systems.
Key Functions:
Backup and Recovery: Tools facilitate regular backups of databases and
provide mechanisms for restoring data in case of failures.
Security Management: They help in implementing and enforcing
security measures, including user access controls and encryption.
Performance Monitoring: These tools monitor database performance,
identifying bottlenecks and optimizing query execution.
Schema Management: Administrators can use these tools to design,
modify, and manage the database schema.
Query Optimization: Some tools analyze and optimize SQL queries to
enhance overall database performance.
Data Migration: Facilitate the transfer of data between databases or
different database systems.
Examples of Tools:
Microsoft SQL Server Management Studio (SSMS): For Microsoft SQL
Server databases.
Oracle Enterprise Manager: Designed for Oracle databases.
phpMyAdmin: A web-based tool for MySQL databases.
c. Arbitrary vs. Descriptive Keys:
Arbitrary Keys:
Definition: Arbitrary keys are identifiers assigned to records without any
inherent meaning or relationship to the data they represent.
Example: A system-generated serial number for a product, serving as a
unique identifier but lacking any specific information about the product
itself.
Advantages: Often simpler and more efficient for database
management. Changes to data (like name changes) don’t impact the
key.
Disadvantages: Lack of semantic meaning can make it challenging for
users to interpret or remember.
Descriptive Keys:
Definition: Descriptive keys are identifiers that carry meaning related to
the attributes or characteristics of the data they represent.
Example: Using a customer’s email address as a key in a customer
database, providing immediate information about the customer.
Advantages: Intuitive and meaningful, making it easier for users to
understand and work with the data.
Disadvantages: Changes to descriptive attributes (like an email address
change) may necessitate updates to the key, potentially impacting
system performance.
In summary, database administration tools streamline the management
of databases, while arbitrary and descriptive keys represent different
approaches to uniquely identify and relate records in a database.
C. Structured Query Language (SQL):
Structured Query Language, commonly known as SQL, is a specialized
programming language designed for managing and manipulating
relational databases.
Here are key points:
Purpose: SQL is used to interact with relational database management
systems (RDBMS) such as MySQL, PostgreSQL, Oracle, and Microsoft
SQL Server. It allows users to define, query, update, and manage data
within a database.
Basic Operations:
Data Querying: SELECT statement is used to retrieve data from one or
more tables.
Data Manipulation: INSERT, UPDATE, and DELETE statements modify
the data in the database.
Schema Definition: CREATE, ALTER, and DROP statements define and
modify the structure of the database.
Data Retrieval:
SQL uses SELECT statements to retrieve data based on specified criteria,
with powerful capabilities like filtering, sorting, and grouping.
Data Modification:
INSERT adds new records, UPDATE modifies existing records, and
DELETE removes records from a table.
Data Integrity:
SQL supports constraints like primary keys, foreign keys, unique
constraints, and check constraints to maintain data integrity and
enforce business rules.
Transactions:
SQL supports transactions, ensuring that a series of database
operations either complete successfully or leave the database
unchanged.
D. Integrity and Security:
Data Integrity:
Entity Integrity: Ensures that each row in a table is uniquely identified
by a primary key.
Referential Integrity: Maintains relationships between tables using
foreign keys to prevent orphaned records.
Security Measures:
Authentication: Verifying the identity of users before granting access to
the database.
Authorization: Controlling the permissions and privileges of users to
restrict access to certain data or operations.
Encryption: Protecting sensitive data by converting it into a secure
format that can only be read with the appropriate decryption key.
Security Best Practices:
Least Privilege Principle: Users should have the minimum level of
access necessary to perform their tasks.
Regular Auditing: Monitoring and reviewing database activities to
identify and address potential security risks.
Data Masking and Redaction: Concealing or anonymizing sensitive
information to protect privacy.
Backup and Recovery:
Regularly backing up databases and implementing recovery
mechanisms to ensure data can be restored in case of accidental loss or
malicious activities.
Compliance:
Adhering to regulatory requirements and industry standards to ensure
that the database management system meets legal and security
standards.
In summary, SQL is a powerful language for managing databases, and
maintaining integrity and security is crucial for protecting data and
ensuring the reliability of database operations.
