CHAPTER 1: EXECUTIVE SUMMARY

Executive Summary
This internship report provides a comprehensive overview of the learning objectives,
outcomes, and activities undertaken during the internship period in the field of Java full stack
developer at WIPRO LIMITED. The internship aimed to provide practical experience and
hands-on learning in the dynamic realm of full stack development. This report highlights the
achievements, learning objectives, sector insights, and intern experiences during the
internship tenure.
Learning Objectives:
To impact good understanding of core concepts, background technologies and sub-
domains of full stack. To get the hands-on experience using full stack technology in real
world.
Course outcomes:
Learn the basic concepts, architecture and standards of full stack. Gain knowledge on
implementation of full stack in real world scenarios.
Mentor ship and Guidance:
Received guidance from experienced mentors, refining technical skills and
understanding industry expectations. In conclusion, the internship at WIPRO LIMITED
provided an enriching experience in the field of full stack, enabling the achievement of
various learning objectives. The combination of theoretical learning and practical application
proved invaluable in building a strong foundation in Java full stack.The exposure to industry
practices and collaborative work environment further enhanced the overall internship
experience.

1
 CHAPTER 2: OVERVIEW OF THE ORGANIZATION
Introduction of the WIPRO ORGANISATION:
Wipro Limited is an Indian multinational technology company that provides information
technology, consulting and business process services. It is one of the six leading Indian Big
Tech companies. Wipro's capabilities range across cloud computing, computer
security, digital transformation, artificial intelligence, robotics, data analytics, and other
technologies, servicing customers in 167 countries.

Vision, Mission, and Values of the WIPRO Organization:

Wipro Limited Mission Statement
The Spirit of Wipro is the core of Wipro. These are our Values. It is about who we are. It is
our character. It is reflected consistently in all our behavior. The Spirit is deeply rooted in the
unchanging essence of Wipro. But it also embraces what we must aspire to be. It is the
indivisible synthesis of the four values. The Spirit is a beacon. It is what gives us direction
and a clear sense of purpose. It energizes us and is the touchstone for all that we do.
Wipro Limited Vision Statement
Contribute for global e-society, where a wide range of information is being exchanged
beyond time and space over global networks, which breaks down the boundaries among
countries, regions and cultures, allowing individuals to take part in various social activities in
an impartial, secure way. Continuous effort to enhance people's lifestyle and quality by
means of developing new technology in wireless communication.
Wipro Limited Values
 Be passionate about clients' success
 Be global and responsible
 Treat each person with respect
 Unyielding integrity in everything we do

2
 CHAPTER 3: INTERNSHIP PART
Activities/Responsibilities in WIPRO Organization:
During the internship at WIPRO LIMITED, the intern was exposed to a range of
activities and responsibilities that provided valuable hands-on experience in the field. These
activities included:
1.Learning and Skill Development: Engaging in self-paced learning modules to grasp
fundamental concepts of Java. Exploring the basics of front-end and back-end development
through online tutorials and resources.
2. Project-based Tasks: Collaborating with the development team on real-world projects,
both individually and in groups, to apply theoretical knowledge to practical scenarios.
Designing and developing new programs.
3. Version Control and Collaboration: Using Git for version control to manage code based
and collaborate effectively with team members. Participating in code reviews and providing
feedback on peers' work.
4. Weekly Work Schedule: The intern's weekly work schedule followed a standard five- day
workweek, typically from Monday to Friday. The workday generally spanned 8 hours, with
flexibility to adjust based on project requirements. Some tasks and projects might
occasionally require extended hours to meet deadlines or address specific challenges.
5. Equipment Used: The intern was provided with a dedicated workstation equipped with a
computer system, necessary software tools (IDE, text editors, browsers), and access to online
development resources. Additionally, the intern had access to communication tools for team
interactions and coordination.
7. Tasks Performed: Throughout the internship, the intern performed tasks such as creating
new programs based on full stack, developing components for full stack applications,
debugging and troubleshooting code issues, collaborating with team members using version
control, and actively participating in project discussions and brainstorming sessions.
Skills acquired:
➢ Technical skills related to their field of study or industry.
➢ Communication and interpersonal skills through collaboration with the colleagues.
➢ Time management and organizational skills by handling multiple tasks.

3
➢ Problem-solving and critical thinking skills by working on real-world challenges.
➢ Adaptability and flexibility in a professional work environment

ACTIVITY LOG FOR THE FIRST WEEK

Day Person In
Brief description of the daily
& Learning Outcome Charge
activity
Date Signature

Monday

Tuesday

Wednesday

Thursday

Friday

4
Saturday

WEEKLY REPORT
WEEK – 1: From 10/06/2024 To 15/06/2024
Introduction:
Java is a high-level, general-purpose, object-oriented, and secure programming
language developed by James Gosling at Sun Microsystems, Inc. in 1991. It is formally
known as OAK. In 1995, Sun Microsystem changed the name to Java. In 2009, Sun
Microsystem takeover by Oracle Corporation.
Features:
A list of the most important features of the Java language is given below:
 Simple
 Object-Oriented
 Portable
 Platform independent
 Secured
 Robust
 Architecture neutral
 Interpreted
 High Performance
 Multithreaded
 Distributed
 Dynamic
Creating Hello World Example:
Class Simple{
Public static void main(String[] args){
System.out.println(“Hello World!”);
}
}
Variables:
Variable is the basic unit of storage in a Java program. These are memory location names
which stores values. A variable is defined by the combination of an identifier, a type, and an
optional initializer. A variable is declared with the following syntax.

5
datatype variable-name = value;
Example int a = 10; Here int is a datatype and a is a variable.
Data Types in Java:
Data types specify the different sizes and values that can be stored in the variable. There are
two types of data types in Java:
1. Primitive data types: The primitive data types include boolean, char, byte, short, int,
long, float and double.

2. Non-primitive data types: The non-primitive data types include classes ,interfaces
and arrays.
Operators in Java:
Operators in Java are the symbols used for performing specific operations in Java. Operators
make tasks like addition, multiplication, etc which look easy although the implementation of
these tasks is quite complex.
1. Arithmetic Operators(+,-,*,/,%)
2. Unary Operators(+,-,++,--,!)
3. Assignment Operator(=,+=,-=,*=,/=,%=)
4. Relational Operators(<,>,==,<=,>=,!=)
5. Logical Operators(&&,||,!)
6. Ternary Operator(?:)
7. Bitwise Operators(&,|,^,~)
8. Shift Operators(<<,>>,>>>)
Java Control Statements:

6
Java compiler executes the code from top to bottom. The statements in the code are executed
according to the order in which they appear. However, it provides statements that can be used
to control the flow of Java code. Such statements are called control flow statements. It is one
of the fundamental features of Java, which provides a smooth flow of program.
Java provides three types of control flow statements.
1. Decision Making statements
o if statements
o switch statement
2. Loop statements
o do while loop
o while loop
o for loop
o for-each loop
3. Jump statements
o break statement
o continue statement
Example:
import java.util.Scanner;
class Even {
public static void main(String[] args){
Scanner sc =new Scanner(System.in);
int num = sc.nextInt();
if (num % 2 == 0) {
System.out.println("Entered Number is Even");
}
else {
System.out.println("Entered Number is Odd");
}
}
}

7
 ACTIVITY LOG FOR THE SECOND WEEK

Day Person In
Brief description of the daily
& Learning Outcome Charge
activity
Date Signature

Monday

Tuesday

Wednesday

Thursday

Friday

Saturday

8
 WEEKLY REPORT
WEEK – 2: From 17/06/2024 To 22/06/2024

Object Oriented Programming (OOPs) Concept in Java:

Object-Oriented Programming (OOP) is a programming paradigm centred on the concepts of
objects and classes. Java, as an object-oriented language, uses these principles to enhance
code structure, modularity, and reusability. Here are the core OOP concepts in Java:
1. Encapsulation
Encapsulation is the concept of wrapping data (fields) and code (methods) together as a
single unit, usually in a class. This is achieved by declaring fields as private and providing
public getter and setter methods to access and modify them. This helps control how data is
accessed and modified, ensuring data integrity.
2. Inheritance
Inheritance allows a class to inherit fields and methods from another class, promoting code
reuse. In Java, inheritance is achieved using the extends keyword, creating a parent-child
relationship between classes.
3. Polymorphism
Polymorphism enables a single action to behave differently based on the context. There are
two main types of polymorphism in Java:
 Compile-time Polymorphism (Method Overloading): Multiple methods with the
same name but different parameters.
 Runtime Polymorphism (Method Overriding): When a subclass provides a specific
implementation of a method already defined in its superclass.
4. Abstraction
Abstraction is the concept of hiding the complex implementation details and showing only
the essential features. This can be achieved using abstract classes and interfaces.
 Abstract Class: A class that cannot be instantiated and may contain abstract methods
(methods without a body).
 Interface: A reference type in Java, similar to a class, that can contain only abstract
methods (prior to Java 8) or default methods.
Summary of OOP Concepts in Java
 Encapsulation: Protects data by keeping it private within the class and using public
methods to access it.
 Inheritance: Allows classes to inherit from other classes, promoting code reuse.
 Polymorphism: Allows methods to have different implementations based on their
context.
 Abstraction: Hides complex details and shows only the relevant parts, using abstract
classes and interfaces.

9
Inheritance:
In Java, inheritance is a core concept in object-oriented programming (OOP) that
allows a class to inherit properties and behaviour (fields and methods) from another class.
This promotes code reusability and establishes a relationship between classes, which is often
referred to as the "is-a" relationship.
Key Concepts of Inheritance
1. Super Class (Parent Class): This is the class whose properties and methods are
inherited by another class. It’s also called the base class.
2. Sub Class (Child Class): This is the class that inherits the properties and methods of
the super class. It's also called the derived or extended class.
3. Keyword extends: In Java, the keyword extends is used to indicate that one class is
inheriting from another.
Types of Inheritance in Java
1. Single Inheritance: A subclass inherits from a single superclass.
2. Multilevel Inheritance: A class is derived from a class that is also derived from
another class.
3. Hierarchical Inheritance: Multiple classes inherit from a single superclass.
Note: Java doesn’t support multiple inheritance with classes (where a class inherits from
more than one class) to avoid complexity and ambiguity (the "diamond problem"). Instead,
Java uses interfaces to support multiple inheritance.
Example of Inheritance in Java
Let’s look at an example where we have a superclass Animal and a subclass Dog that inherits
from Animal.
// Superclass
class Animal {
String type = "Mammal";
void eat() {
System.out.println("Eating...");
}
}
// Subclass
class Dog extends Animal {
String breed = "Golden Retriever";
void bark() {
System.out.println("Barking...");

10
 }
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
// Accessing properties and methods from both superclass and subclass
System.out.println("Type: " + dog.type); // Inherited from Animal
dog.eat(); // Inherited method from Animal
System.out.println("Breed: " + dog.breed); // Defined in Dog
dog.bark(); // Defined in Dog
}
}
Output:
Type: Mammal
Eating...
Breed: Golden Retriever
Barking...
Benefits of Inheritance
 Code Reusability: Common code can be written in a superclass and reused by
subclasses, reducing redundancy.
 Polymorphism: Allows dynamic method dispatch, where a superclass reference can
point to subclass objects, enabling polymorphic behaviour.
Key Points
 super Keyword: Used to refer to the immediate superclass and can be used to access
superclass fields, methods, or constructors.
 Method Overriding: A subclass can provide a specific implementation of a method
already defined in its superclass, which enables polymorphism.

ACTIVITY LOG FOR THE THIRD WEEK

11
 Day Person In
Brief description of the daily
& Learning Outcome Charge
activity
Date Signature

Monday

Tuesday

Wednesday

Thursday

Friday

Saturday

12
 WEEKLY REPORT
WEEK – 3: From 24/06/2024 to 29/06/2024
Introduction:
JUnit is a popular open-source framework used for unit testing in Java. It was initially
developed by Erich Gamma and Kent Beck as part of the xUnit family of frameworks, which
are widely used in test-driven development (TDD). JUnit allows developers to write and run
repeatable tests, ensuring that their code works as expected and helping to catch bugs early in
the development process. The latest versions of JUnit are JUnit 5 (also known as Jupiter),
which introduces a modular and more flexible approach compared to previous versions.
Features:
Some of the key features of JUnit include:
 Annotation-driven: Uses annotations like @Test, @BeforeEach, @AfterEach, etc.,
to define test methods and lifecycle hooks.
 Assertions: Provides various assertion methods to validate the test outcomes, such as
assertEquals, assertTrue, and assertNotNull.
 Flexible Test Execution: Allows selective test execution and provides options to run
specific test cases, classes, or packages.
 Exception Testing: Allows testing for expected exceptions with assertThrows.
 Parameterized Tests: Supports parameterized testing, where tests can be run multiple
times with different inputs.
 Integration with Build Tools: Compatible with tools like Maven, Gradle, and IDEs
like IntelliJ IDEA and Eclipse, making it easy to integrate into build pipelines.
Basic JUnit Example:
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class CalculatorTest {
@Test
public void testAddition() {
Calculator calc = new Calculator();
int result = calc.add(2, 3);
assertEquals(5, result, "2 + 3 should equal 5");
}
}

13
Key Annotations in JUnit:
JUnit offers several annotations to simplify test setup, execution, and teardown:
1. @Test - Marks a method as a test case.
2. @BeforeEach - Executes before each test case, useful for setting up common test
data.
3. @AfterEach - Executes after each test case, commonly used for cleanup.
4. @BeforeAll - Executes once before all test cases, typically used for setting up
expensive resources.
5. @AfterAll - Executes once after all test cases, generally used for cleanup.
6. @Disabled - Disables a test, helpful when a test is incomplete or broken.
Assertions in JUnit:
Assertions are used to check if the tested code behaves as expected. Some common assertions
in JUnit are:
 assertEquals - Checks if two values are equal.
 assertNotEquals - Checks if two values are not equal.
 assertTrue - Verifies that a condition is true.
 assertFalse - Verifies that a condition is false.
 assertNull - Checks if an object is null.
 assertNotNull - Checks if an object is not null.
 assertThrows - Verifies that a specific exception is thrown.
Example :
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertThrows;
public class ExceptionTest {
@Test
public void testForException() {
assertThrows(ArithmeticException.class, () -> {
int division = 10 / 0;
});
}
}
Parameterized Tests in JUnit:

14
JUnit 5 introduces parameterized tests, which allow running the same test with different
inputs, thus improving test coverage and reducing redundant code.
Example :
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
public class ParameterizedTestExample {
@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 4, 5})
public void testWithMultipleInputs(int number) {
assertTrue(number > 0, "The number should be positive");
}
}
JUnit Control Statements:
JUnit follows the order in which test methods are defined, but it also provides mechanisms to
control test execution flow. JUnit doesn’t directly support control statements like loops or
conditionals within annotations, but these can be managed within the test methods
themselves, making the tests more flexible.

15
 ACTIVITY LOG FOR THE FOURTH WEEK

Day Person In
Brief description of the daily
& Learning Outcome Charge
activity
Date Signature

Monday

Tuesday

Wednesday

Thursday

Friday

16
Saturday

WEEKLY REPORT
WEEK – 4: From 01/07/2024 To 06/07/2024

Welcome to HTML and CSS

HTML (Hypertext Markup Language) and CSS (Cascading Style Sheets) are the
building blocks of the web. Together, they form the backbone of web development, enabling
you to create visually appealing and functional websites.

What is HTML?

● HTML was first introduced in 1993 by Tim Berners-Lee, the inventor of the World
Wide Web. Since then, it has undergone several revisions, with the most recent
version being HTML5 (introduced in 2014).

● HTML is a standard markup language used to create the structure and content of web
pages. It consists of elements represented by tags (<>), which wrap around content to
define its purpose. HTML is responsible for:

- Defining the structure of a web page (headings, paragraphs, images, links, etc.)

- Creating hyperlinks between web pages

- Embedding multimedia content (images, videos, audio)

● HTML5 (2014) is the latest version.

What is CSS?

● CSS was first introduced in 1996 by the World Wide Web Consortium (W3C) to
provide a standard way to style web pages.
● CSS stands for Cascading Style Sheets. It's a styling language used to control the
layout and appearance of web pages written in HTML or XML. CSS is a crucial part
of web development, as it allows developers to separate the presentation layer from
the structure (HTML) and content.

HTML Overview:

Basic Structure:

<!DOCTYPE html>

<html>

<head>

17
 <!-- Metadata and links to external files -->

</head>

<body>

<!-- Content of the webpage -->

</body>

</html>

Basic Components

● Elements: HTML consists of elements represented by tags (<>) that wrap around
content.
● Tags: Opening (<) and closing (>) tags surround content.
● Attributes: Provide additional information about elements.

Common HTML Elements

● Headings: <h1>, <h2>, <h3>, etc.

● Paragraphs: <p>
● Links: <a>
● Images: <img>
● Lists: <ul>, <ol>, <li>
● Tables: <table>, <tr>, <td>
● Forms: <form>, <input>, <textarea>

CSS Overview:

Basic Structure:

selector {

property: value;

property: value;

Components:

1. Selector: Targets the HTML element(s) to apply styles to.

2. Property: Specifies the style attribute (e.g., color, font-size, margin).

3.Value: Defines the value of the property (e.g., #fff, 18px, 10%).

CSS Structure:

1. Ruleset (or Declaration Block)

18
selector {

property: value;

2. Declarations

property: value;

3. Properties

- Color properties (e.g., color, background-color)

- Font properties (e.g., font-size, font-family)

- Layout properties (e.g., width, height, margin)

- Positioning properties (e.g., position, top, left)

4. Selectors

- Element Selectors (e.g., h1, p)

- Class Selectors (e.g., .header, .footer)

- ID Selectors (e.g., #nav, #sidebar)

- Combinators (e.g., >, +, ~)

5. Preprocessor Directives

- @import (imports another CSS file)

- @media (defines media queries)

- @keyframes (defines animations)

Basic CSS Example

body {

font-family: Arial, sans-serif;

background-color: #f2f2f2;

.container {

max-width: 800px;

margin: 0 auto;

19
 padding: 20px;

ACTIVITY LOG FOR THE FIFTH WEEK

Day Person In
Brief description of the daily
& Learning Outcome Charge
activity
Date Signature

Monday

Tuesday

Wednesday

Thursday

Friday

20
Saturday

WEEKLY REPORT
WEEK – 5: From 08/07/2024 To 13/07/2024
Introduction:
JavaScript is a weekly typed (dynamically typed), lightweight, cross-platform, single-
threaded, and interpreted compiled programming language. It is also known as the scripting
language for webpages. It is well-known for the development of web pages, and many non-
browser environments also use it.

Features:
A list of the most important features of the Java language is given below:
 Event Handling
 Platform Independent
 Async Processing
 Prototype-based
 Interpreter
 Objects as first-class citizens
 Functions as First-Class Citizens
 Date and Time Handling
 Light Weight
 Dynamic Typing
Variables:
In JavaScript variables are used to store and manage data. They are used to store reusable
values. The values of the variables are allocated using the assignment operator (“=”). They
are created using the var, let, or const keyword.
1. var Keyword: The var keyword is used to declare a variable. It has a function-scoped
or globally-scoped behaviour.
Example: var x = 10;
2. let Keyword: The let keyword is a block-scoped variables. It’s commonly used for
variables that may change their value.
Example: let y = "Hello";
3. const Keyword: The const keyword declares variables that cannot be reassigned.
It’s block-scoped as well.
Example: const PI = 3.14;
Data Types in JavaScript:

21
In JavaScript, variables can receive different data types over time. The latest ECMAScript
standard defines eight data types Out of which seven data types are Primitive
(predefined) and one complex or Non-Primitive.
3. Primitive data types: The predefined data types provided by JavaScript language are
known as primitive data types. Primitive data types are also known as in-built data
types.
Data Type Description
String Represents sequence of characters
e.g. "hello"
Number Represents numeric values e.g. 100
Boolean Represents boolean value either false or true
Undefined Represents undefined value
car = undefined;
Null Represents null i.e. no value at all
Symbol Return unique identifiers that can be used as property keys in
objects without colliding with other keys.
BigInt A built-in object that provides a way to represent whole numbers
larger than 2^53-1.

4. Non-primitive data types: The data types that are derived from primitive data types
of the JavaScript language are known as non-primitive data types. Objects, Arrays are
non-primitive data types in javascript.
Object: const person = {firstName:"John", lastName:"Doe", age:50,
eyeColor:"blue"};
JavaScript Control Statements:
JavaScript control statement is used to control the execution of a program based on a specific
condition. If the condition meets then a particular block of action will be executed otherwise
it will execute another block of action that satisfies that particular condition.
JavaScript provides three types of control flow statements.
4. Conditional statements
o if statement
o if-else statement
o switch statement
5. Iterative statements
o do while loop
o while loop
o for loop
6. Jump statements
o break statement

22
 o continue statement

Example:
let num = -10;
if (num > 0)
console.log("The number is positive.");
else
console.log("The number is negative");
Document Object Model:
DOM, or Document Object Model, is a programming interface that represents structured
documents like HTML and XML as a tree of objects. It defines how to access, manipulate,
and modify document elements using scripting languages like JavaScript.
The DOM is a W3C (World Wide Web Consortium) standard and it defines a standard for
accessing documents.
The W3C Dom standard is divided into three different parts:
 Core DOM – standard model for all document types
 XML DOM – standard model for XML documents
 HTML DOM – standard model for HTML documents
Methods Of DOM Object:
Method Description
Write(“string”) Writes the given string on the document.
getElementById() Returns the element having the given id value.
getElementsByName() Returns all the elements having the given name
value.
getElementsByTagName() Returns all the elements having the given tag name.
getElementsByClassName() Returns all the elements having the given class
name.

23
 ACTIVITY LOG FOR THE SIXTH WEEK

Day Person In
Brief description of the daily
& Learning Outcome Charge
activity
Date Signature

Monday

Tuesday

Wednesday

Thursday

24
 Friday

Saturday

WEEKLY REPORT
WEEK – 6: From 15/07/2024 To 20/07/2024
Introduction:
SQL stands for Structured Query Language. SQL is a computer language used to
interact with relational database systems. SQL is a tool for organizing, managing, and
retrieving archived data from a computer database. SQL is divided into three main
components: Data Definition Language (DDL), Data Control Language (DCL), and Data
Manipulation Language (DML).

SQL Commands:
There are four types of SQL commands: DDL, DML, DCL, TCL.

1. Data Definition Language (DDL) :

DDL changes the structure of the table like creating a table, deleting a table, altering a table,
etc. All the command of DDL are auto-committed that means it permanently save all the
changes in the database.

a.CREATE: It is used to create a new table in the database.

Syntax : CREATE TABLE TABLE_NAME (COLUMN_NAMES DATATYPES [ ...]);

25
Example:
CREATE TABLE EMPLOYEE(Name VARCHAR2(20), Email VARCHAR2(100), DOB DA
TE);
b. DROP: It is used to delete both the structure and record stored in the table.
Syntax: TABLE table_name [cascade constraint];

Example: DROP TABLE EMPLOYEE;

c. ALTER: The ALTER TABLE command adds, deletes, or modifies columns in a

table.The ALTER TABLE command also adds and deletes various constraints in a table.

Example
1. ALTER TABLE: ALTER TABLE Customers ADD Email varchar(255);
2. ALTER COLUMN: ALTER TABLE Employees ALTER COLUMN BirthDate year;
d. TRUNCATE: It is used to delete all the rows from the table and free the space containing
the table.
Syntax: TRUNCATE TABLE table_name;

Example: TRUNCATE TABLE EMPLOYEE;

e. Rename: It is used to rename the table.

Syntax: Rename <OLD_TABLENAME> to <NEW_TABLENAME>;

Example: Rename STU_NAME to STUDENT_NAME;

2.Data Manipulation Language:

DML commands are used to modify the database. It is responsible for all form of changes in
the database. The command of DML is not auto-committed that means it can't permanently
save all the changes in the database. They can be rollback.

a.INSERT: The INSERT statement is a SQL query. It is used to insert data into the row of a
table. To insert a new row into a table you must be your on schema or INSERT privilege on
the table.

Syntax: INSERT INTO TABLE_NAME (col1,.... col N) VALUES (value1.... valueN);

Example: INSERT INTO javatpoint (Author, Subject) VALUES ("Sonoo", "DBMS");

b. UPDATE: This command is used to update or modify the value of a column in the table.

Syntax:
UPDATE table_name SET [column_name1= value1,...column_nameN = valueN] [WHERE
CONDITION]

Example: UPDATE students SET User_Name = 'Sonoo' WHERE Student_Id = '3'

26
c. DELETE: It is used to remove one or more row from a table. To delete rows from the
table, it must be in your schema or you must have delete privilege.

Syntax: DELETE FROM table_name [WHERE condition];

Example: DELETE FROM javatpoint WHERE Author="Sonoo";

d. SELECT: This is the same as the projection operation of relational algebra. It is used to
select the attribute based on the condition described by WHERE clause.

Syntax: SELECT expressions FROM TABLES WHERE conditions;

Example: SELECT emp_name FROM employee WHERE age > 20;

3.Data Control Language:

a.GRANT: Assigns new privileges to a user account, allowing access to specific database
objects, actions, or functions.

Syntax: GRANT <obj_priv> ON <obj_name> To <username>;

In the above syntax, obj_priv> is the DML statement like Insert, Delete , update and Select
and <obj_name> is a table, view etc. and username is the name of the authorized user.

Example:
GRANT SELECT, UPDATE ON MY_TABLE TO SOME_USER, ANOTHER_USER;

b. Revoke: It is used to take back permissions from the user.

Syntax: REVOKE <obj_priv> ON <obj_name> FROM <username>;

Example: REVOKE SELECT, UPDATE ON MY_TABLE FROM USER1, USER2;

4. Transaction Control Language:

a. Commit: Commit command is used to save all the transactions to the database. It makes
your changes permanent and ends the transaction.

Syntax:COMMIT;

Example:DELETE FROM CUSTOMERS WHERE AGE = 25; COMMIT;

b. Rollback: Rollback command is used to undo transactions that have not already been
saved to the database. Rollback also serves to end the current transaction and begin a new
one.

Syntax: To remove the changes ROLLBACK;

Example: DELETE FROM CUSTOMERS WHERE AGE = 25; ROLLBACK;

27
c. SAVEPOINT: It is used to roll the transaction back to a certain point without rolling back
the entire transaction.

Syntax: SAVEPOINT SAVEPOINT_NAME;

In the above syntax, SAVEPOINT_NAME is the name given to savepoint.

To selectively ROLLBACK a group of statements within a large transaction use the following
command is used.

Rollback TO <save_point_name>
Example:DELETE FROM CUSTOMERS WHERE AGE = 15;
SAVEPOINT A; DELETE FROM CUSTOMERS WHERE AGE = 35; ROLLBCAK TO A;

ACTIVITY LOG FOR THE SEVENTH WEEK

Day Person In
Brief description of the daily
& Learning Outcome Charge
activity
Date Signature

Monday

Tuesday

Wednesday

28
 Thursday

Friday

Saturday

WEEKLY REPORT
WEEK – 7: From 22/07/2024 To 27/07/2024
Introduction:
Java Servlets are the Java programs that run on the Java-enabled web server or
application server. They are used to handle the request obtained from the web server, process
the request, produce the response, and then send a response back to the web server.
Properties of Java Servlet:
 Servlets work on the server side.
 Servlets are capable of handling complex requests obtained from the web server.

Servlets Architecture:

Servlets Tasks:

29
  Read the explicit data sent by the clients (browsers). This includes an HTML form on
a Web page or it could also come from an applet or a custom HTTP client program.
 Read the implicit HTTP request data sent by the clients (browsers). This includes
cookies, media types and compression schemes the browser understands, and so forth.
 Process the data and generate the results. This process may require talking to a
database, executing an RMI or CORBA call, invoking a Web service, or computing
the response directly.
 Send the explicit data (i.e., the document) to the clients (browsers). This document
can be sent in a variety of formats, including text (HTML or XML), binary (GIF
images), Excel, etc.
 Send the implicit HTTP response to the clients (browsers). This includes telling the
browsers or other clients what type of document is being returned (e.g., HTML),
setting cookies and caching parameters, and other such tasks.
Servlets APIs:
 javax.servlet(Basic)
 javax.servlet.http(Advance)
Servlets - Life Cycle:
A servlet life cycle can be defined as the entire process from its creation till the
destruction. The following are the paths followed by a servlet.

 The servlet is initialized by calling the init() method.

 The servlet calls service() method to process a client's request.
 The servlet is terminated by calling the destroy() method.
 Finally, servlet is garbage collected by the garbage collector of the JVM.

The init() Method:

The init method is called only once. It is called only when the servlet is created, and not
called for any user requests afterwards. So, it is used for one-time initializations, just as with
the init method of applets.

The init method definition looks like this −

public void init() throws ServletException {

// Initialization code...
}

The service() Method:

The service() method is the main method to perform the actual task. The servlet container
(i.e. web server) calls the service() method to handle requests coming from the
client( browsers) and to write the formatted response back to the client.

Here is the signature of this method −

public void service(ServletRequest request, ServletResponse response)

throws ServletException, IOException {
}

30
The doGet() Method:

A GET request results from a normal request for a URL or from an HTML form that has no
METHOD specified and it should be handled by doGet() method.

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {
// Servlet code
}
The doPost() Method:
A POST request results from an HTML form that specifically lists POST as the METHOD
and it should be handled by doPost() method.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
}

The destroy() Method:

The destroy() method is called only once at the end of the life cycle of a servlet. This method
gives your servlet a chance to close database connections, halt background threads, write
cookie lists or hit counts to disk, and perform other such cleanup activities.

After the destroy() method is called, the servlet object is marked for garbage collection. The
destroy method definition looks like this −

public void destroy() {

// Finalization code...
}

Architecture Diagram

31
 ACTIVITY LOG FOR THE EIGHTH WEEK

Day Person In
Brief description of the daily
& Learning Outcome Charge
activity
Date Signature

Monday

Tuesday

Wednesday

32
 Thursday

Friday

Saturday

WEEKLY REPORT
WEEK – 8: From 29/07/2024 To 03/08/2024
Spring Boot:
1. Introduction to Spring Boot
Spring Boot is a powerful framework designed to simplify the development of Java-based
applications by providing a production-ready environment with minimal configuration. Built
on top of the Spring Framework, Spring Boot eliminates the need for extensive boilerplate
code and configurations, enabling developers to focus on building functionality rather than
managing infrastructure. With embedded server support (e.g., Tomcat, Jetty), Spring Boot
enables the creation of stand-alone applications that can run independently without a
dedicated application server.
Key Benefits of Spring Boot:
 Ease of Setup: With “opinionated defaults,” Spring Boot automatically configures the
application based on the dependencies in the project.
 Embedded Servers: It supports embedded servers like Tomcat and Jetty, allowing
applications to be launched directly.
 Microservices Ready: Spring Boot is well-suited for building scalable microservices.
 Flexible and Modular: Offers a variety of starter dependencies to simplify the
integration of common functionalities.
Spring Boot has become popular for its efficiency in building both monolithic applications
and distributed microservices architectures.
2. Core Features of Spring Boot

33
Spring Boot is centered around several core features that simplify application development
and management.
Auto-Configuration

Spring Boot’s auto-configuration feature automatically sets up application configurations

based on the dependencies specified in the project. This approach removes much of the
manual setup associated with traditional Spring applications.
Dependency Injection (DI)
Spring Boot leverages Spring’s Dependency Injection to manage components and services,
making code loosely coupled, which is essential for modular, testable applications. DI allows
objects to be provided at runtime, enhancing flexibility and reusability.
Spring Boot Starters
Starters are dependency descriptors that include a set of related libraries. For instance:
 spring-boot-starter-web - Contains everything needed to create web applications,
including RESTful services.
 spring-boot-starter-data-jpa - Facilitates database interaction using JPA (Java
Persistence API).
 spring-boot-starter-security - Adds security configurations and libraries to the
application.
These predefined starter dependencies streamline the process of adding common
functionalities, saving developers time and effort.
3. Building RESTful APIs with Spring Boot
One of the most common uses of Spring Boot is building RESTful APIs. These APIs allow
applications to communicate over HTTP, typically in JSON format.
Creating REST Endpoints
Spring Boot enables quick creation of REST endpoints using the @RestController and
@RequestMapping annotations. For example:
@RestController
@RequestMapping("/api")
public class SampleController {
@GetMapping("/greeting")
public String greet() {
return "Hello, Spring Boot!";
}
}
Handling Requests and Responses
Spring Boot integrates seamlessly with HTTP methods, like GET, POST, PUT, and DELETE,

34
to handle standard RESTful operations. Responses are typically returned in JSON format and
are automatically converted by Spring Boot’s built-in Jackson library.
Testing APIs
Spring Boot also supports easy testing of REST endpoints using tools like Spring Boot’s
TestRestTemplate and popular external tools like Postman.
4. Database Integration with Spring Data JPA
Spring Boot simplifies database interaction with Spring Data JPA (Java Persistence API).
Spring Data JPA abstracts the data layer, making database operations like CRUD (Create,
Read, Update, Delete) easy to implement.
Database Configuration
With a few lines in application. Properties, databases can be configured quickly. Here’s an
example of configuring an H2 in-memory database:
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
Using JPA Repositories
JPA repositories provide predefined methods like findAll(), save(), and deleteById(), so
there’s no need to write SQL queries. Custom queries can be created using method naming
conventions or with the @Query annotation.
public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByLastName(String lastName);
}
This integration saves time and enhances maintainability by automating repetitive database
interactions.
5. Microservices with Spring Boot
Spring Boot is a natural choice for building microservices, which are small, loosely coupled
services that can be deployed and scaled independently.
Key Components for Microservices
 Spring Cloud: Extends Spring Boot to provide tools like Eureka (for service
discovery) and Zuul (for routing).
 Spring Boot Actuator: Provides production-ready features for monitoring and
managing applications, like health checks, metrics, and tracing.
 Distributed Configuration: Spring Cloud Config allows microservices to share
configurations, which can be stored and accessed centrally.
Service Discovery and Load Balancing

35
Eureka, a component of Spring Cloud, helps microservices register and discover each other,
promoting load balancing and failover support.
Circuit Breakers and Resilience
Spring Boot integrates with tools like Hystrix, allowing services to remain resilient by
managing failures gracefully and preventing cascading failures.
6. Conclusion
Spring Boot has revolutionized the way developers create applications, offering both
simplicity and flexibility for full-stack and back-end development. With auto-configuration,
embedded servers, and a vast ecosystem of modules and plugins, Spring Boot is an essential
framework for Java developers, especially for those looking to build scalable, production-
grade applications. Its strong support for RESTful APIs, database integration, and
microservice architecture has cemented its status as a go-to framework for modern web and
enterprise applications.

CHAPTER 4: OUTCOMES DESCRIPTION

WIPRO Work Environment:
People Interactions:
At WIPRO organization, the work environment emphasizes open and transparent
communication. Employees, including interns, engage in regular discussions, idea-sharing,
and feedback sessions Managers and mentors encourage an approachable atmosphere where
questions and discussions are welcomed.
Facilities and Maintenance:
WIPRO organization prioritizes providing a comfortable workspace for its employees.
Ergonomic furniture, well-lit spaces, and modern equipment contribute to the well-being and
productivity of the workforce. Regular maintenance ensures that facilities are in good
condition.
Clarity of Job Roles:
Clear job descriptions and well-defined roles are communicated to interns and
employees. This ensures that each individual understands their responsibilities and can
contribute effectively to projects and tasks.
Procedures, and Processes:
WIPRO organization follows standardized protocols and procedures for various tasks,
especially in the context of projects and platform operations. These processes helps to
maintain consistency and quality in the work delivered.
Discipline and Time Management:
Time management is crucial at WIPRO, considering the dynamic nature of the
organization. Interns are encouraged to manage their time effectively, meet deadlines, and
prioritize tasks to achieve optimal results.
Harmonious Relationships:

36
WIPRO organization fosters a culture of inclusively and respect, where all employees and
interns are treated fairly and respectfully. Diversity is celebrated, creating an environment
where everyone feels valued.
Socialization and Mutual Support:
Regular team-building activities, workshops, and events are organized to promote
socialization among interns and employees. A sense of mutual support is encouraged, where
individuals readily assist one another.
Teamwork and Collaboration:
Collaboration is a key aspect of the WIPRO work environment. Interns work together
on projects and tasks, often collaborating with experienced employees and mentors. Cross-
functional teams contribute diverse skills and perspectives to projects.
Motivation and Recognition:
WIPRO organization values the efforts of its interns and employees. Regular
feedback, recognition programs, and opportunities for professional growth contribute.
Space and Ventilation:
The workspace at WIPRO organization is designed to provide a comfortable and well-
ventilated environment. Adequate space and suitable lighting contribute to a positive working
atmosphere. In this hypothetical depiction, the WIPRO work environment embodies values of
collaboration, professionalism, respect, and continuous learning. It is designed to provide
interns and employees with opportunities for growth, skill development, and meaningful
contributions to the organization’s mission.

37
Real-Time Technical Skills Acquired in an Internship
During an internship at WIPRO organization, individuals may acquire a variety of
technical skills related to their job roles. For instance, in the context of a Embedded system,
some technical skills might include

Programming Languages: Proficiency in languages such as Java,HTML,CSS being used.

Database Management:
Designing and working with databases, including CRUD (Create, Read, Update,
Delete) operations.
Version Control:
Using tools like Git for code collaboration, version management, and team
coordination.
Managerial Skills Acquired During Internship:
An internship can also help individuals develop various managerial skills that
contribute to their professional growth. These skills are valuable regardless of the specific
role.
Planning and Goal Setting:
Learning how to set achievable goals, create project plans, and prioritize tasks
effectively.
Leadership and Teamwork:
Participating in team projects, collaborating with colleagues, and taking on leadership
roles when appropriate.
Effective Communication:
Improving written and verbal communication skills to convey ideas clearly and
professionally.
Time Management:
Learning to manage time efficiently, meet deadlines, and balance multiple tasks.
Problem Solving and Decision Making:
Analysing challenges, considering alternatives, and making informed decisions.
Adaptability:
Being flexible and open to change, particularly in fast-paced environments like tech
companies.
Feedback and Improvement:
Receiving feedback constructively, reflecting on personal performance, and making
continuous improvements.
Work Ethic and Professionalism:
Demonstrating dedication, punctuality, accountability, and a strong work ethic.
Performance Analysis:
Evaluating project outcomes, identifying areas for improvement, and implementing
changes based on feedback.
Debugging and testing:
Development to identify and fix errors, ensuring the system works reliably and
effectively. These processes involve using various tools and techniques to isolate and resolve
issues, verifying the system meets requirements and functions as intended.

38
Improving Communication Skills

Practice Active Listening: Focus on understanding what others are saying rather than just
waiting for your turn to speak. This improves your comprehension and responsiveness in
conversations.
Expand Vocabulary: Regularly read books, articles, and engage m discussions to expose
yourself to new words and phrases, which can enrich your language and expressions.
Confidence Building: Practice speaking in front of a mirror or with friends and family
Gradually, you'll become more confident in expressing your thoughts.
Anxiety Management: Deep breathing exercises and positive self-talk can help manage
anxiety while communicating, promoting a more relaxed demeanour structured Responses:
Organize your thoughts before speaking. This helps you present your ideas coherently and
succinctly.
Conversational Abilities: Engage in diverse conversations, from casual chats to more formal
discussions, to adapt your communication style to different contexts.
Effective Writing: Regular writing, whether through journaling, emails, or blog posts, helps
improve your written communication skills and articulation.
Understanding Others: Practice empathy to understand others' perspectives and concerns.
This enhances your ability to communicate effectively and build rapport.
Articulate Key Points: Learn to express complex ideas concisely. Focus on the main points
while ensuring clarity.
Managing Conversational Closures: Learn to conclude conversations with appropriate
closing statements, which can be a summary of the key points discussed or expressing a
willingness to continue the dialogue.

Enhancing Abilities in Group Discussions and Teamwork:

Active Participation: Engage actively in group discussions by contributing meaningful

insights and ideas. Avoid dominating the conversation and encourage others to speak.
Listening to Others: Give each team member the opportunity to share the views Listen
attentively, ask questions, and acknowledge their contributions.
Constructive Feedback: Provide feedback in a respectful and constructive manner This
fosters a collaborative environment where everyone's opinions are valued.
Leading by Example: If you're leading a team or activity, demonstrate qualities like
organization, punctuality, and open communication. Lead with integrity and fairness.
Delegate Tasks: Distribute tasks based on team members' strengths and interests Effective
delegation ensures everyone's skills are utilized optimally.
Conflict Resolution: Address conflicts or disagreements promptly and professionally. Seek
common ground and find solutions that benefit the entire team.
Encourage Inclusivity: Create an environment where everyone feels comfortable sharing
their ideas and opinions, regardless of their role or experience level.
Celebrate Achievement: Acknowledge and appreciate the team's achievements. Recognize the
efforts of individuals and the collective progress made.
Time Management: Ensure team discussions and activities are well-structured and stay on
schedule. Respect your teammates' tune.
Continuous Improvement: Regularly assess the team's processes and outcomes Encourage
open discussions about what went well and what can be improved.

39
 Student Self Evaluation of the Short-Term Internship

Student Name: BATCHU MOUNIKA

Registration No: 21731A3103

Term of Internship: From: 10/06/2024 To : 03/08/2024

Date of Evaluation:

Organization Name : WIPRO LIMITED

Please rate your performance in the following areas:

Rating Scale: Letter grade of CGPA calculation to be provided

1 Oral communication 1 2 3 4 5
2 Written communication 1 2 3 4 5
3 Pro activeness 1 2 3 4 5
4 Interaction ability with community 1 2 3 4 5
5 Positive Attitude 1 2 3 4 5
6 Self-confidence 1 2 3 4 5
7 Ability to learn 1 2 3 4 5
8 Work Plan and organization 1 2 3 4 5
9 Professionalism 1 2 3 4 5
10 Creativity 1 2 3 4 5
11 Quality of work done 1 2 3 4 5
12 Time Management 1 2 3 4 5
13 Understanding the Community 1 2 3 4 5
14 Achievement of Desired Outcomes 1 2 3 4 5
15 OVERALL PERFORMANCE 1 2 3 4 5

Date: Signature of the Student

Evaluation by the Supervisor of the Intern Organization

40
 Student Name: BATCHU MOUNIKA

Registration No: 21731A3103

Term of Internship: From: 10/06/2024 To: 03/08/2024

Date of Evaluation:

Organization Name :WIPRO LIMITED

Please rate the student’s performance in the following areas: Please note that your evaluation
shall be done independent of the Student’s self evaluation.

Rating Scale: 1 is lowest and 5 is highest rank

1 Oral communication 1 2 3 4 5
2 Written communication 1 2 3 4 5
3 Pro activeness 1 2 3 4 5
4 Interaction ability with community 1 2 3 4 5
5 Positive Attitude 1 2 3 4 5
6 Self-confidence 1 2 3 4 5
7 Ability to learn 1 2 3 4 5
8 Work Plan and organization 1 2 3 4 5
9 Professionalism 1 2 3 4 5
10 Creativity 1 2 3 4 5
11 Quality of work done 1 2 3 4 5
12 Time Management 1 2 3 4 5
13 Understanding the Community 1 2 3 4 5
14 Achievement of Desired Outcomes 1 2 3 4 5
15 OVERALL PERFORMANCE 1 2 3 4 5

Date: Signature of supervisor

41
 INTERNAL ASSESSMENT STATEMENT
Name of the Student:
Register No:
Year of Study: IV B.Tech, I-Semester
Group: COMPUTER SCIENCE ENGINEERING-ARTIFICIAL INTELLIGENCE
Name of the College: PBR VISVODAYA INSTITUTE OF TECHNOLOGY & SCIENCE
University: AUTONOMOUS
Program of Study: Semester Internship

Maximum Marks
Sl.No Evaluation Criterion
Marks Awarded
1 Activity Log 10
2 Internship Evaluation 20
3 Oral Presentation 10
4 Viva-Voice 10
GRAND TOTAL 50

42
 EXTERNAL ASSESSMENT STATEMENT
Name of the Student:
Register No:
Year of Study: IV B.Tech, I-Semester
Group: COMPUTER SCIENCE ENGINEERING-ARTIFICIAL INTELLIGENCE
Name of the College: PBR VISVODAYA INSTITUTE OF TECHNOLOGY & SCIENCE
University: AUTONOMOUS
Program of Study: Semester Internship

Maximum Marks
Sl.No Evaluation Criterion
Marks Awarded
1. Internship Evaluation 20

For the grading giving by the Supervisor of the

2. 10
Intern Organization

3. Viva-Voice 20
TOTAL 50

GRAND TOTAL (EXT. 50 M + INT. 50M) 100

43