Report of JAVA Dev

An
Internship Report
On
“JAVASCRIPT”
From
UDEMY
Course Name – “The Complete JavaScript Course”
Submitted By –
Dev Verma
2101330130044
Under Supervision of
Dr. Amba Mishra Ms. Shruti Sinha

(Assistant Professor) (Assistant Professor)
Noida Institute of Engineering and Technology
Department of Information Technology
November 2022
Session: 2022-23 Internship Report Department of IT

Index
Sr. No. Title Page No.

1. Introduction 01
2. Index 02
3. Course Certificate 03
4. Declaration 04
5. Course Objective 05
6. Perquisite Knowledge Required 06
7. Course Modules 07-18
8. Brief description of Course 19
9. Application of the course 20-21
10. Course learning outcomes 22
11. Advanced course suggested for future 23

Training Certificate

DECLARATION
I hereby declare that this Training Report entitled (“JAVASCRIPT”) is an

authentic record of the training done by me in the month of September 2022 of
42 Days (6 Weeks) for the award of degree B. Tech (Information Technology),
NOIDA INSTITUTE OF ENGINEERING & TECHNOLOGY, under the
guidance ofDr. Amba Mishra and Ms. Shruti Sinha.
Dev Verma
University Roll No. –
2101330130109
Date: 10/10/2022
Certified that the above statement made by the student is correct to the best of
our knowledge and belief.
Examined By:
1. Dr. Amba Mishra
2. Ms. Shruti Sinha
Head of Department
(Signature)

Course Objective
 To understand the basic concepts and fundamentals of the

programming language Java.
 Be able to use the Java SDK environment to create, debug and
run simple java programs.
 To understand the installing of Java JDK and understand the
working of the code on different stage of execution.
 To understand the object-oriented features of the programming
language Java.
 To demonstrate the skills in writing programs using the
techniques like exceptional handling and file handling.
 To understand the JavaFX concepts.
 To demonstrate the program to present the User Interface (UI)
of any mobile application and software.
 To understand the application of Java programming language
and to develop the various real-life project using Java.

Perquisite Knowledge Required
 You must know at least the basics of how to use a computer, and should
be able to start a command line shell.
 Knowledge of basic programming concepts.
 Some basic like to install the required software and other required
extensions.

Course Modules
This course of Java Script (JS) contains the following Modules:
 Module 1: Getting Started with Java Script
 Module 2: Leveraging Basic Concepts
 Module 3: Object Based Programming using Java Script
 Module 4: JavaScript Frameworks for App Development
Under these modules we will gain knowledge from the basic concepts of java
script to the Modern Java Script Development.
Different modules focus on the specific field of the java script programming
language and hence starting from the basics of java script then the next module
is about the concepts of loops and other topics like the Exception handling and
file handling after that the next module is giving you information about the
object-based programming using java script and then the last module is making
us friendly with the concepts of Modern Java Script Development and making
Web pages and sites using it.

MODULE 1: Getting Started with JAVA SCRIPT
Module outcome: This module is to understand the basics of JavaScript

programming language.
1. Introduction:
 JavaScript is a programming language that adds interactivity to
your website. This happens in games, in the behaviour of responses
when buttons are pressed or with data entry on forms; with
dynamic styling; with animation, etc.
2. What is JavaScript?
 JavaScript is a powerful programming language that can add

interactivity to a website. It was invented by Brendan Eich.
 JavaScript is versatile and beginner-friendly. With more
experience, you'll be able to create games, animated 2D and 3D
graphics, comprehensive database-driven apps, and much more!
 JavaScript itself is relatively compact, yet very flexible.
Developers have written a variety of tools on top of the core
JavaScript language, unlocking a vast amount of functionality with
minimum effort.
3. A Hello World! Example:
 JavaScript is one of the most popular modern web technologies! As

your JavaScript skills grow, your websites will enter a new dimension
of power and creativity.
1. Go to your test site and create a new folder named scripts. Within
the scripts folder, create a new text document called main.js, and
save it.
2. In your index.html file, enter this code on a new line, just before
the closing </body> tag:
3. <script src="scripts/main.js"></script>

4. Variables:
 Variables are containers that store values. You start by declaring a

variable with the let keyword, followed by the name you give to the
variable:
let myVariable;
 A semicolon at the end of a line indicates where a statement ends.

It is only required when you need to separate statements on a
single line.
 JavaScript is case sensitive. This means myVariable is not the

same as myvariable. If you have problems in your code.
 After declaring a variable, you can give it a value:

myVariable = "Bob";
 Also, you can do both these operations on the same line:

let myVariable = "Bob";
 You retrieve the value by calling the variable name:

myVariable;
 After assigning a value to a variable, you can change it later in

the code:
let myVariable = "Bob";
myVariable = "Steve";
 Comments:
 Comments are snippets of text that can be added along with code.
The browser ignores text marked as comments.
/*
Everything in between is a comment.

*/
 Operators:
 An operator is a mathematical symbol that produces a result

based on two values (or variables). In the following table, you
can see some of the simplest operators, along with some
examples to try in the JavaScript console.
Operator Explanation Symbol(s) Example

Add two numbers together or 6 + 9;
Addition combine two strings. + 'Hello ' + 'world!';
Subtraction, These do what you'd expect 9 - 3;

Multiplication, them to do in basic math. -, *, / 8 * 2; // multiply in JS is an
asterisk
Division
9 / 3;
Assignment As you've seen already: this let myVariable = 'Bob';
assigns a value to a variable. =
Strict equality This performs a test to see if let myVariable = 3;
two values are equal. It returns === myVariable === 4;
a true/false (Boolean) result.
For "Not", the basic

expression is true, but the
comparison returns false
because we negate it:
let myVariable = 3;
This returns the logically
!(myVariable === 3);
opposite value of what it
"Does-not-equal" gives
precedes. It turns a true into a
!, !== basically the same result with
false, etc.. When it is used different syntax. Here we are
alongside the Equality testing "is myVariable NOT
Not,Does-not- operator, the negation equal to 3". This returns false
equal operator tests whether two because myVariable IS equal
values are not equal. to 3:
let myVariable = 3;
myVariable !== 3;

 Conditionals:
 Conditionals are code structures used to test if an expression

returns true or not. A very common form of conditionals is the
if...else statement.
 For example:
let iceCream = "chocolate";

if (iceCream === "chocolate") {
alert("Yay, I love chocolate ice cream!");
} else {
alert("Awwww, but chocolate is my favorite…");
}
The expression inside the if () is the test. This uses the strict equality
operator (as described above) to compare the variable iceCream with
the string chocolate to see if the two are equal. If this comparison
returns true, the first block of code runs. If the comparison is not
true, the second block of code—after the else statement—runs
instead.
 Functions:
 Functions are a way of packaging functionality that you wish to

reuse. It's possible to define a body of code as a function that
executes when you call the function name in your code. This is
a good alternative to repeatedly writing the same code. You
have already seen some uses of functions. For example:
let myVariable = document.querySelector("h1");

alert("hello!");
These functions, document.querySelector and alert, are built
into the browser.

 Events:
 Real interactivity on a website requires event handlers. These

are code structures that listen for activity in the browser, and
run code in response. The most obvious example is handling the
click event, which is fired by the browser when you click on
something with your mouse. To demonstrate this, enter the
following into your console, then click on the current webpage:
document.querySelector("html").addEventListener("click",
function () {
alert("Ouch! Stop poking me!");
});
 There are a number of ways to attach an event handler to an

element. Here we select the <html> element. We then call its
addEventListener() function, passing in the name of the event to
listen to ('click') and a function to run when the event happens.
 The function we just passed to addEventListener() here is called

an anonymous function, because it doesn't have a name. There's
an alternative way of writing anonymous functions, which we
call an arrow function. An arrow function uses () => instead of
function ():
document.querySelector("html").addEventListener("click"()=>{
alert("Ouch! Stop poking me!");
});

Module 2: Leveraging Basic Concepts
 If you want to carve a career in web development, then learning

JavaScript should be on your to-do list. Besides, JavaScript is the
most popular programming language. Because JavaScript helps in
creating some aesthetic and interactive front-end elements. That’s
why you may find the implementation of JavaScript on an
extensive scale.
1. Grab the knowledge about basics
 When it comes to basics, JavaScript is not complicated. Yes, there

are huge terms like jQuery, TypeScript, etc., that might confuse
you. But it is all because of the updates that have been happening
in the language from time-to-time. Therefore, when it comes to
‘must know’ JavaScript concepts. Then start with basic features
like error handling, if/else, string manipulation, and so on. Also,
get a hang of the variable access wherein there are two – Global
scope and local scope.
2. Error handling
 Errors are bound to popup in coding. But one thing every

JavaScript developer should know is to detect and correct the
errors. Moreover, the latest version of JavaScript is a boon as it
allows error handling in multiple ways. Above all, one important
tip on JavaScript for beginners is to understand the syntaxes
properly. It will make it easier for you to identify the errors while
undertaking a code review.
3. Know everything about developer tools
 When it comes to highlighting JavaScript concepts for beginners,

then it is vital to know about debugging. One should ably debug
and inspect how the system works. And if you need help, then
JavaScript has an amazing set of developer tools for detecting bugs
in code and further inspecting it. Learning these tools will help you
sail through your JavaScript tutorials.

4. Become an expert in JavaScript functions
 Functions are the fundamental aspect of the JavaScript language.

Therefore, one thing to know before learning JavaScript is – all
about functions. Understand the scope of the function, their
workflow, the difference between normal functions as well as
arrow functions, and much more. Furthermore, the developer
should know how to utilize functions to divide the code efficiently.
5. Get equipped with basic designing knowledge
 Now you might wonder, why JavaScript developers have to design

elements. Well, there could be times when the visual designer
might not turn up. Else, there could be conflict in interest with the
designers. Then with basic knowledge of designing, you may strike
a communication with the designing team. You may bridge the gap
while fulfilling the product designing requirements. Therefore, it is
good to have some knowledge of designing while learning
JavaScript for beginners.
6. Gain knowledge of Node.js tools
 In the last few years, there has been a gamut of new things in
JavaScript. There have been many tools like eslint, Babel, that are
proving to be a boon to many. Well, you might not know how to
write an application in Node.js, but try and understand the usage of
these tools. Start learning about the installation of Node while
updating packages. Well, there are many libraries and tools, but
getting familiar with the Node ecosystem will prove beneficial for
beginners.
7. Brief knowledge about the overall performance of JavaScript
 Debugging is very important to map the processes. Therefore, it is

important to know all about debugging slower processes because
they showcase the root cause of the problems. You must know the

factors that are causing problems in the code. Alongside this, you
must also focus on the UI, data structures, and algorithms because
they will give you information about data handling. This
knowledge will not be a waste rather it will augment your
experience.
8. Have reference notes by your side
 When a thought – “what to know about JavaScript,” boggles you.

Then you can quickly refer to a guide or notes to unearth such
queries. Reference notes are a boon when you are stuck on difficult
concepts that are impossible to crack. Reference notes are filled
with examples that will help you sail smoothly. Moreover, they
also have a collection of older versions of syntaxes; in case if you
come across any! Now, these reference notes can be in the form of
online videos, guides, courses or communities. Most importantly,
don’t just refer but take notes as you gain knowledge.
9. Knack for exploring new things
 JavaScript has witnessed some major evolutions. And in the

coming years, there are going to be more changes. So, it is very
important to be prompt to accept these changes. Not just accept but
keep a tab on the latest trends. Follow social media accounts,
subscribe to newsletters, podcasts, online resources to keep a tab
on every happening. You may also join a community to get in
touch with like-minded people. It will keep you updated as well as
amplify your knowledge.

Module 3: Object Based Programming using Java Script
 Object-oriented programming (OOP) is a programming paradigm

fundamental to many programming languages, including Java and C+
+. In this article, we'll provide an overview of the basic concepts of
OOP. We'll describe three main concepts: classes and instances,
inheritance, and encapsulation.
 Object-oriented programming is about modeling a system as a

collection of objects, where each object represents some particular
aspect of the system. Objects contain both functions (or methods) and
data. An object provides a public interface to other code that wants to
use it but maintains its own private, internal state; other parts of the
system don't have to care about what is going on inside the object.
Classes and instances
 When we model a problem in terms of objects in OOP, we create

abstract definitions representing the types of objects we want to have
in our system. For example, if we were modeling a school, we might
want to have objects representing professors. Every professor has
some properties in common: they all have a name and a subject that
they teach. Additionally, every professor can do certain things: they
can all grade a paper and they can introduce themselves to their
students at the start of the year, for example.
 So Professor could be a class in our system. The definition of the class

lists the data and methods that every professor has.
 In pseudocode, a Professor class could be written like this:

class Professor
properties
name

teaches
methods
grade(paper)
introduceSelf()
 This defines a Professor class with:
o two data properties: name and teaches
o two methods: grade() to grade a paper and introduceSelf() to

introduce themselves.
 On its own, a class doesn't do anything: it's a kind of template for

creating concrete objects of that type. Each concrete professor we
create is called an instance of the Professor class. The process of
creating an instance is performed by a special function called a
constructor. We pass values to the constructor for any internal state
that we want to initialize in the new instance.
 Generally, the constructor is written out as part of the class definition,

and it usually has the same name as the class itself:
class Professor
properties
name
teaches
constructor
Professor(name, teaches)
methods
grade(paper)
introduceSelf()
 This constructor takes two parameters, so we can initialize the name

and teaches properties when we create a new concrete professor.
 Now that we have a constructor, we can create some professors.
Programming languages often use the keyword new to signal that a
constructor is being called.
walsh = new Professor("Walsh", "Psychology");
lillian = new Professor("Lillian", "Poetry");
walsh.teaches; // 'Psychology'
walsh.introduceSelf(); // 'My name is Professor Walsh and I will be your
Psychologyprofessor.'

lillian.teaches; // 'Poetry'
lillian.introduceSelf(); // 'My name is Professor Lillian and I will be your Poetry
professor.'
Inheritance
 Suppose in our school we also want to represent students. Unlike

professors, students can't grade papers, don't teach a particular subject,
and belong to a particular year.
 However, students do have a name and may also want to introduce

themselves, so we might write out the definition of a student class like
this:
class Student
properties
name
year
constructor
Student(name, year)
methods
introduceSelf()
 We start by observing that students and professors are both people, and
people have names and want to introduce themselves. We can model this
by defining a new class Person, where we define all the common
properties of people. Then, Professor and Student can both derive from
Person, adding their extra properties:
class Person
properties
name
constructor
Person(name)
methods
introduceSelf()
class Professor : extends Person

properties
teaches
constructor
Professor(name, teaches)
methods
grade(paper)
introduceSelf()

class Student : extends Person
properties
year
constructor
Student(name, year)
methods
introduceSelf()
 In this case, we would say that Person is the superclass or parent class of
both Professor and Student. Conversely, Professor and Student are
subclasses or child classes of Person.
You might notice that introduceSelf() is defined in all three classes. The
reason for this is that while all people want to introduce themselves, the
way they do so is different:
walsh = new Professor("Walsh", "Psychology");

walsh.introduceSelf(); // 'My name is Professor Walsh and I will be your
Psychology professor.'
summers = new Student("Summers", 1);

summers.introduceSelf(); // 'My name is Summers and I'm in the first
year.'
We might have a default implementation of introduceSelf() for people

who aren't students or professors:
pratt = new Person("Pratt");

pratt.introduceSelf(); // 'My name is Pratt.'
 This feature - when a method has the same name but a different
implementation in different classes - is called polymorphism. When a
method in a subclass replaces the superclass's implementation, we say
that the subclass overrides the version in the superclass.

Encapsulation
 Objects provide an interface to other code that wants to use them but
maintain their own internal state. The object's internal state is kept
private, meaning that it can only be accessed by the object's own
methods, not from other objects. Keeping an object's internal state
private, and generally making a clear division between its public interface
and its private internal state, is called encapsulation.
 This is a useful feature because it enables the programmer to change the

internal implementation of an object without having to find and update all
the code that uses it: it creates a kind of firewall between this object and
the rest of the system.
 For example, suppose students are allowed to study archery if they are in
the second year or above. We could implement this just by exposing the
student's year property, and other code could examine that to decide
whether the student can take the course:
if (student.year > 1) {
// allow the student into the class
}
 The problem is, if we decide to change the criteria for allowing students
to study archery - for example by also requiring the parent or guardian to
give their permission - we'd need to update every place in our system that
performs this test. It would be better to have a canStudyArchery() method
on Student objects, that implements the logic in one place:

properties
year
constructor
Student(name, year)
methods

introduceSelf()
canStudyArchery() { return this.year > 1 }
if (student.canStudyArchery()) {
// allow the student into the class
}
That way, if we want to change the rules about studying archery, we only have
to update the Student class, and all the code using it will still work.
In many OOP languages, we can prevent other code from accessing an object's
internal state by marking some properties as private. This will generate an error
if code outside the object tries to access them:
properties
private year
constructor
Student(name, year)
methods
introduceSelf()
canStudyArchery() { return this.year > 1 }
student = new Student('Weber', 1)

student.year // error: 'year' is a private property of
Student
o In languages that don't enforce access like this,

programmers use naming conventions, such as starting
the name with an underscore, to indicate that the
property should be considered private.
 constructors in JavaScript provide us with something like a class

definition, enabling us to define the "shape" of an object, including any
methods it contains, in a single place. But prototypes can be used here,
too. For example, if a method is defined on a
constructor's prototype property, then all objects created using that
constructor get that method via their prototype, and we don't need to
define it in the constructor.

 the prototype chain seems like a natural way to implement inheritance.
For example, if we can have a Student object whose prototype is Person,
then it can inherit name and override introduceSelf().
 First, in class-based OOP, classes and objects are two separate constructs,
and objects are always created as instances of classes. Also, there is a
distinction between the feature used to define a class (the class syntax
itself) and the feature used to instantiate an object (a constructor). In
JavaScript, we can and often do create objects without any separate class
definition, either using a function or an object literal. This can make
working with objects much more lightweight than it is in classical OOP.
 Second, although a prototype chain looks like an inheritance hierarchy

and behaves like it in some ways, it's different in others. When a subclass
is instantiated, a single object is created which combines properties
defined in the subclass with properties defined further up the hierarchy.
With prototyping, each level of the hierarchy is represented by a separate
object, and they are linked together via the __proto__ property. The
prototype chain's behavior is less like inheritance and more
like delegation. Delegation is a programming pattern where an object,
when asked to perform a task, can perform the task itself or ask another
object (its delegate) to perform the task on its behalf. In many ways,
delegation is a more flexible way of combining objects than inheritance
(for one thing, it's possible to change or completely replace the delegate
at run time).
 That said, constructors and prototypes can be used to implement class-

based OOP patterns in JavaScript. But using them directly to implement
features like inheritance is tricky, so JavaScript provides extra features,
layered on top of the prototype model, that map more directly to the
concepts of class-based OOP. These extra features are the subject of the
next article.

Module 4: Java Script Frameworks for App Development
 Even as app development becomes increasingly robust and complex,

JavaScript remains one of the most popular programming languages. Data
from 2021 says that about 65% of developers use it more often than any
other language. That makes it the top language worldwide.
 Exploring the Java syntax also comes with a variety of options - this
article dives into the top frameworks for businesses of all sizes.
 JavaScript frameworks are well-suited to mobile app development, as

they can be used across a number of platforms, including iOS, Android,
and Windows.
Top 6 JavaScript Frameworks for Mobile App Development:

The top 6 JavaScript frameworks for mobile apps are:
1. jQuery Mobile
2. React Native
3. NativeScript
4. Ionic
5. Titanium
6. Meteor
1. jQuery Apps Load Quickly
Perhaps the biggest advantage of building apps using jQuery Mobile is

the speed at which the applications load.

As a lightweight framework, it’s based on the jQuery library and has a
strong focus on compatibility with a specific runtime environment, so it
can be used for all of the following products:
oAndroid
oWindows
oBlackberry
oiOS
Along with asynchronous loading, jQuery eliminates the need for device-
specific languages, so developers can use standards such as JavaScript,
HTML5, and CSS3. It also mitigates cross-browser issues and supports a
number of display sizes and screen resolutions.
jQuery can also be used to create custom themes using the ThemeRoller
web app. It provides various tools that make editing themes
straightforward, including its drag-and-drop color picker, page layouts,
and header templates.
Using these themes can create a supreme user experience with any web
browser or mobile app.
2. React Native Integrates With Other Programs
 As an open-source framework, React Native can be used for building

cross-platform native apps. When used in combination with
JavaScript, React Native applications are indistinguishable from
apps built using other languages such as Swift, Java, and
Objective-C.
 React Native has the edge over other frameworks due to its
declarative programming style and reusable components for user
interfaces.

 It can be combined with native code written in other programming
languages, making the React framework very flexible and a good
choice for adding new features to existing applications.
 With the introduction of a new feature called Hooks, the popularity

of the framework among JavaScript development services will
likely continue.
 The feature enables developers to access React's features without

writing a class, which makes for a more intuitive approach.
3. NativeScript Allows Code to Be Reused
 Developers with existing JavaScript skills can transition to the

NativeScript framework fairly easily.
 NativeScript can be used to build multi-platform native apps or web

pages from a single code source.
 It uses a “write once, use everywhere” approach and enables code to

be reused between platforms, which makes development time
quicker. Because it’s open-source and free, there are no associated
costs of working with the framework.
 NativeScript provides developers with access to hundreds of plugins

via CocoaPods for iOS and Gradle for Android.
 The framework also has its own exclusive plugins. Additionally, the
NativeScript community creates hundreds of additional new
plugins each year.
 Interested in learning more about front-end development services?

Check out a beginner’s guide that dives into the importance of
annotated wireframes.
4. Ionic Can Build on Multiple Platforms

 Developers who are already familiar with app or software development
will understand easily the structure of the Ionic framework. Its hybrid app
codebase enables developers to build apps for multiple platforms,
reducing overall development costs and the application’s time to market.
 With Ionic, developers have access to Cordova plugins that enhance the
performance and scalability of the framework and enable developers to
expand its use. This improves the accessibility of scripting. The
flexibility with Ionic can also halt the occurrence of debugging.
 Application testing is easy with Ionic as there are four options, enabling
developers to choose the approach that suits them best.
 Testing can be carried out on a desktop using the WebKit browser, in an

iOS or Android simulator, in a mobile browser, or as a native app on the
device itself.
5. Titanium Is Ideal for Prototypes
 Titanium, developed by mobile technology company Appcelerator,

is one of the oldest frameworks available for hybrid mobile apps. It
provides easy access to functionalities that enable developers to
build high-performance applications.
 One of the main benefits of Titanium is that it enables fast

prototyping as part of its integrated environment. This allows
developers to create working applications quickly in order to
validate ideas and design approaches.
 The framework also lets developers reuse 60% to 90% of code when
supporting multiple platforms, and there are hundreds of modules
that provide additional capabilities.
 To date, mobile developers have deployed more than 75,000 mobile

apps on 280 million devices using Titanium, making it a very
popular web framework.

6. Meteor Increases Efficiency
 Meteor (or meteor.js) is a full-stack Javascript framework that caters

especially well to small businesses and startups that are looking to
get a product off the ground quickly without sacrificing modern
features that customers have come to expect.
 Written in Node.js, Meteor easily fits into a MEAN stack, which is

growing in popularity with developers in recent years. Meteor is
known for being easy to learn, allowing small businesses to launch
fully-functioning apps in weeks rather than months.
 While the framework is highly preferred by web developers, it is

easy for teams to convert web products to mobile apps.
 The framework is a huge time-saver and offers a great deal of

support, both from the company itself and through community-
created content.

Brief description of Course
This course is a collection of 4 modules and the duration of this course is 6

weeks.
Under this course we are mastering the JavaScript concepts where we are
learning about the topics through the videos that are available all the time on the
site.
You can test your knowledge by the topic-wise test at the end of every topic,
module test at the end of every module and the Final Test which is to test the
total outcome of the course.
In this the first module is setting up the base for this new journey and helping
you to install the required software and other required extensions for the set-up
of the environment for JavaScript and making you understand about the basic
concepts.
In the second module is helping you to understand a level up of the basic

javascript.
In the third module it is helping you to understand the Object-Oriented

programming concepts in JavaScript. Like inheritance, polymorphism, abstract
keyword, static keyword, class and objects and others.

In the fourth module it is helping you to develop a desktop application with the
help of the NativeScript, jQuery etc. coding where we are also using the Scene
Builder for the development of the application.
Application of Course
 Web Development:
JavaScript is a scripting language used to develop web pages. Developed

in Netscape, JS allows developers to create a dynamic and interactive
web page to interact with visitors and execute complex actions. It also
enables users to load content into a document without reloading the
entire page. Most websites use JavaScript for validation and to support
external applications, including PDF documents, widgets, flash
applications. Some of the world’s largest tech companies use JavaScript
to better the user experience.
Some famous websites built by the use of JavaScript are Google,

YouTube, Facebook, Wikipedia, Yahoo, Amazon, eBay, Twitter, and
LinkedIn, to name a few.
 Web Applications:
Various JavaScript frameworks are used for developing and building

robust web applications. In an application like Google Maps, if users
want to explore a map, all they have to do is click and drag the mouse to
get a detailed view. This is powered by JavaScript, which interacts with
the browser without communicating with the servers. Popular JavaScript

front-end frameworks that help build web apps are React Native, React,
Angular and Vue. Netflix and PayPal were developed with AngularJS
JavaScript framework and Application Programming Interfaces (APIs).
 Presentations:
A very popular application of JavaScript is to create interactive

presentations as websites. The RevealJs and BespokeJs libraries can be
used to generate web-based slide decks using HTML. The RevealJs
helps create interactive slide decks with transitions styles, themes, and
slide backgrounds in all CSS color formats. The BespokeJs is a feature-
heavy framework that includes features like scaling, animated bullet
lists, syntax highlighting, etc.
 Server Applications:
JavaScript is also used to write server-side software through Node.js

open-source runtime environment. Developers can write, test and debug
code for fast and scalable network applications. JavaScript helps to
generate content and manage HTTP requests. Top companies like
Walmart, PayPal, Uber, GoDaddy, and many more have adopted Node.js
for server infrastructure.
 Web Servers:
Node.js allows developers to use JavaScript to create a web server.

Node.js being event-driven, it moves to the next call without waiting for
the response of the previous call. The servers quickly transfer chunks of
data without buffering. The HTTP module uses the createServer ()
method for creating a server.
 Games:
Creating games on the web is another important one among applications

of JavaScript. The combination of JavaScript and HTML5 plays a major
role in games development using JS. The EaselJS library provides rich
graphics for games. HTML5 provides total access to the web without
additional plugins like Flash. Complex browser games Tower Building,
CrossCode, HexGL game are based on JavaScript and HTML5.

 Mobile Apps:
One of the most powerful applications of JavaScript is to create apps for

non-web contexts, meaning for things, not on the Internet. With the use
of mobile devices at an all-time high, JavaScript frameworks have been
designed to facilitate mobile app development across various platforms
like IOS, Android, and Windows. React Native framework allows cross-
platform mobile app building, where developers can use a universal front
end for Android and IOS platforms.
Course learning outcomes
 At the end of the course, you are able to understand the basic concepts of
the JavaScript Programming and Scripting language.
 At the end of the course, you are able to build basic code of JavaScript
programming language.
 At the end of the course, you are able to understand the implementation
of the iterators and conditional statements.
 At the end of the course, you are able to understand the concepts of
classes and objects.
 At the end of the course, you are able to understand the concept of OOPs
in JavaScript programming language.

 At the end of the course, you are able to understand and implementation
of the concepts like Inheritance, Events, Abstraction and Encapsulation.
 At the end of the course, you are able to code using the jQuery and Ionic.
 At the end of the course, you are able to use the scene builder for the use
of desktop application development and web development.
Advance Course Suggested for Future
In future I will try to enroll myself for the course “Android App
Development” from Udemy.
The content of this course is making you able to develop a fully working web
Application with the help of Java Script Programming Language.
The perquisite knowledge for the course is Java Script Programming Language.
So this will be a better option after completing this course.
Outcomes of the Course:
 At the end of the course, you are able to develop a proper working web
application using javascript.
 At the end of the course, you are able to use your knowledge and it
implement in the real word to solve real life problems.


Report of JAVA Dev

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Report of JAVA Dev

Uploaded by

Copyright:

Available Formats

An

Dr. Amba Mishra Ms. Shruti Sinha

Noida Institute of Engineering and Technology

Department of Information Technology

Session: 2022-23 Internship Report Department of IT

Sr. No. Title Page No.

Session: 2022-23 Internship Report Department of IT

Session: 2022-23 Internship Report Department of IT

I hereby declare that this Training Report entitled (“JAVASCRIPT”) is an

Session: 2022-23 Internship Report Department of IT

 To understand the basic concepts and fundamentals of the

Session: 2022-23 Internship Report Department of IT

 Knowledge of basic programming concepts.

Session: 2022-23 Internship Report Department of IT

This course of Java Script (JS) contains the following Modules:

 Module 1: Getting Started with Java Script

 Module 2: Leveraging Basic Concepts

 Module 3: Object Based Programming using Java Script

 Module 4: JavaScript Frameworks for App Development

Session: 2022-23 Internship Report Department of IT

Module outcome: This module is to understand the basics of JavaScript

 JavaScript is a powerful programming language that can add

3. A Hello World! Example:

 JavaScript is one of the most popular modern web technologies! As

Session: 2022-23 Internship Report Department of IT

 Variables are containers that store values. You start by declaring a

 A semicolon at the end of a line indicates where a statement ends.

 JavaScript is case sensitive. This means myVariable is not the

 After declaring a variable, you can give it a value:

 Also, you can do both these operations on the same line:

 You retrieve the value by calling the variable name:

 After assigning a value to a variable, you can change it later in

Session: 2022-23 Internship Report Department of IT

 An operator is a mathematical symbol that produces a result

Operator Explanation Symbol(s) Example

Subtraction, These do what you'd expect 9 - 3;

For "Not", the basic

Session: 2022-23 Internship Report Department of IT

 Conditionals are code structures used to test if an expression

let iceCream = "chocolate";

 Functions are a way of packaging functionality that you wish to

let myVariable = document.querySelector("h1");

Session: 2022-23 Internship Report Department of IT

 Real interactivity on a website requires event handlers. These

 There are a number of ways to attach an event handler to an

 The function we just passed to addEventListener() here is called

Session: 2022-23 Internship Report Department of IT

 If you want to carve a career in web development, then learning

1. Grab the knowledge about basics

 When it comes to basics, JavaScript is not complicated. Yes, there

 Errors are bound to popup in coding. But one thing every

3. Know everything about developer tools

 When it comes to highlighting JavaScript concepts for beginners,

Session: 2022-23 Internship Report Department of IT

 Functions are the fundamental aspect of the JavaScript language.

5. Get equipped with basic designing knowledge

 Now you might wonder, why JavaScript developers have to design

6. Gain knowledge of Node.js tools

7. Brief knowledge about the overall performance of JavaScript

 Debugging is very important to map the processes. Therefore, it is

Session: 2022-23 Internship Report Department of IT

8. Have reference notes by your side

 When a thought – “what to know about JavaScript,” boggles you.