WHAT IS SOFTWARE ?
A computer system consists of two parts – hardware and software. The first part, computer hardware, refers to all the visible components of the computer system: keyboard, monitor, hard disc, printer, scanner, processing unit, memory, electrical connections, etc. It does all of the physical work a computer is known for. The second part is a set of simple and step-by-step sequence of instructions that tell the hardware what to do and how to do it. This organized set of instructions written in a defined order and to accomplish a specific task is called computer software or computer program. Hence, a computer software provides intelligence to the hardware, which otherwise is just a collection of circuits and pieces of plastic and metal.
A computer programmer writes the software that gives a computer the ability to solve any business or scientific problem.
Figure: Relationship between Hardware and Software
You already know that the computer hardware is essentially a piece of complex electronics that understands only 1's and 0's – electrical ―on‖ or ―off‖ conditions. Hence, the instructions to perform a task must be written in a series of binary 1's and 0's. But, although this binary format, called the machine code makes perfect sense to a machine, it is incomprehensible to a computer programmer who writes the program. So a programmer codes the program in the English like programming language which is easier to understand. This program is then translated into machine code by another computer program. This translated program, called the software is eventually executed to achieve the desired goal.
You will study about types of software and its evolution in the following sections.
WHAT IS SOFTWARE EVOLUTION
As you know that in a computer system both hardware and software complement each other – one is of hardly any use without the other. Hence, since the very beginning of computer history, software evolution has been closely tied to the advances made in hardware. As hardware became faster, cheaper and with better capacity of storage, software became more complex and sophisticated.
Over the decades computers have been used in new areas and to solve new problems. With changing needs and improved hardware, the software has evolved in its various aspects. The software architecture, its design paradigms, programming languages, its usage, costing and licensing have all changed and evolved over the years.
Figure: Different Aspects of Software Evolution
Software evolution with respect to its architecture, design styles, programming
| ||
language and licensing will be covered in the following section.
|
Evolution of Software Architecture
The software architecture has always moved in unison with the hardware advancement.
Mainframe Architecture
Till a few decades back, all computing was controlled through the central mainframes server. Multiple users could connect to the central host through unintelligent terminals which captured the keystrokes, sent the information to the host and displayed the text output. All the processing was done by the applications residing on the main central server. Only large transaction-oriented applications were developed during that time. Business tasks such as accounts receivable, accounts payable, general ledger, credit account management and payroll that were repetitive and could be run as batch jobs were automated.
In these centralized computing models, the host provided both the data storage and processing power for the client systems. There was no support for graphical user interface or access to multiple databases from geographically dispersed sites.
Figure: Mainframe Architecture
File Sharing Architecture
The development of microprocessor, PC and LAN transformed dumb terminals into ―smart‖ clients. This brought a complete change in the computing environment. The client workstations or desktops, with there enhanced capabilities were now responsible for the user interface and execution of the application logic. The server provided access to computing resources like printers and large hard drives for storing the files. It downloaded the file from the shared location on the server to the client machine. The user application that worked on the data was run on the client and the file was written back to the server. The application had to be installed on each workstation that accessed the file.
In this architecture, resources could be added as and when necessary or desired. Thus, it provided a low cost entry point with flexible arrangement. The drawback
was that application logic was executed on the client and server typically provided files to store data. It worked fine as long as the volume of data transfer was low and shared usage and content update was low. As the number of online users grew, the network traffic got congested and the file sharing got strained. Taking into account the demerits of the file server architectures, the client/ server architecture made its advent.
What is Client/ Server Architecture
As the capacity and power of personal computers improved, the need to share the processing demands between the host server and the client workstation increased. This need for greater computing control and more computing value led to the evolution of client/server technology.
In client/server architecture, the tasks or workloads are partitioned as:
server programs – providers of a resource or service
client programs – requester of resource or service
Clients and servers may reside in the same machine or they typically reside in separate pieces of hardware and communicate over a computer network. A server machine is a host that runs one or more server programs which share their resource with clients. A client does not share any of its resources, but requests a server function or service. The server program fulfills the client request. Clients initiate a communication session with the server.
The client/ server system may be two-tiered, three-tiered or n-tiered.
Two-tiered architecture: This approach basically introduced a database server to replace the file server. The emergence of relational database management systems and graphical user interface applications led to database server which could be accessed through the GUI based client applications. Since, the clients query the database over the network and only the relevant data is supplied to the client, the network traffic is greatly reduced in comparison to the file server system.
The application or business logic in client server applications may reside on the server (fat server – thin client) or on the client (fat client – thin server). Since,
clients and server interact over the network, increases in the number of users often lead to network congestion. Also, maintenance of the application becomes difficult with more users. This lack of scalability (Ability of a system to support increased demands of work, usage or service levels almost instantly, without any change and with no significant drop in cost effectiveness or quality of service) and flexibility gave rise to 3-tiered and n-tiered architectures.
Figure: Two Tier Client Server Architecture
Figure: Three Tier Client Server Architecture
N-tiered architecture: The 3-tier architecture can be extended to N-tiers when the middle tier provides connections to various types of services, integrating and coupling them to the client, and to each other. Partitioning the application logic among various hosts can also create an N-tiered system. Encapsulation of distributed functionality in such a manner provides significant advantages such as reusability, and thus reliability (Ability of a computer program to perform its intended functions and operations for the specified period of time, in the specified system's environment, without experiencing any failure).
Figure: N-Tier Client Server Architecture
Database
Figure: N-Tiered Client Server Architecture
Internet-based architecture: In the late 1990's, the client/server trend was augmented by the internet. The users access the web servers through the web browsers on the client machines and over the internet. This led to very thin client based applications, which reside on corporate web servers.
The advantage of web based applications is that they do not have to be tailored to run on specific platforms. But since the web applications cannot perform client-side processing, they limit the user experience by turning the client computers into ―dumb‖ terminals. Web mails, online transactions are examples of web applications.
Figure: Internet Based Architecture
Cloud Computing
As the technology has evolved from Mainframe-based large proprietary (Computer Programs that are exclusive property of their developers or publishers, and cannot be copied or distributed without complying with their licensing agreements) systems to Client-Server architecture based open systems to Open
Source software based solutions, software vendor's business has also evolved over the period of time. Cloud-based software services typically mean that the consumer does not own the hardware and software, but still gets the desired service. It is an IT delivery model that offers large-scale, shared infrastructure and computing resources as a service through self-service pay-per use access. Although it leverages recently developed technology, cloud computing is a business, not a technical trend.
Here is some background for the evolution of these services. As the new software vendors tried to establish themselves in the market, they created solution differentiators which provide unique value to the consumers. An example is Salesforce.com, which from the inception offered a hosted Customer Relationship Management (CRM) solution, while its established competitors (Siebel, SAP, PeopleSoft etc) had their traditional (also called On Premise, meaning at the customer site in its dedicated environment) CRM solution. Another reason is that software vendors started targeting a niche customer segment called Small & Medium Business (SMB). SMB customers are relatively new in business, so need to establish the core IT systems in place and also have lesser financial strength, as a result are more open towards cloud-based solution.
An early example of cloud based computing is web-based emails (hotmail, yahoo, gmail etc), Chat (AOL, MSN etc). Here the required computer resources are provisioned centrally in the cloud (internet) and shared by the user pool. These days, more often, software is bundled with the required shared infrastructure to provide a solution stack to the consumer.
Key features of cloud computing are:
Infrastructure sharing: Cloud computing enables dynamic sharing of resources so that demands can be met cost effectively.
Scalability: To handle ever increasing workload demands and support the entire enterprise, cloud computing must have the flexibility to significantly scale IT resources.
Self service: Cloud computing provides customers with access to IT resources through service-based offerings. The details of IT resources and their setup are transparent to the users.
Pay-per-use: Because cloud resources can be added and removed according to workload demand, users pay for only what they use and are not charged when their service demands decrease.
There is another term that is associated with cloud computing:
Software-as-a-Service (SaaS), Platform-as-a-Service (PaaS) – also referred to as On Demand software. This is a software solution delivery model where the software and the associated data are hosted centrally (in the cloud) and are accessed by the consumer through a thin client such as a web browser. Common applications for this are business applications such as – Accounting, Collaboration (Email, Messenger, Web meeting etc), Customer Relationship Management (CRM), Enterprise Resource Planning (ERP), Human Resource Management etc.
Key benefits of Cloud-based solutions are:
Lower upfront cost to get started, lower time-to-market (as it takes less time to get a customer going on a cloud solution), allows the company to focus on the core business and not worry about hiring and constantly training its staff on the new technology etc.
On the flip side for a Cloud-based solution, certain segment of customers such as large Banks and Financial institutions, Insurance companies may have security constraints in letting their data reside outside its premises (in their own data centers).
Evolution of Software Design Paradigm
As the software evolved in its complexity, architecture and use, and as the programming languages got better, styles of software programming also changed and improved.
One of the longest standing goals of software design is reusability which leads to increased reliability, accelerated development and easy maintenance. Over the years, software languages and software design paradigms which have evolved, all encourage compartmentalization of functionality to achieve this goal. Similar functionality is grouped together into small, independent and reusable units. These units can be used in any application for the purpose for which they were originally intended.
The first step towards compartmentalization was moving from line by line non structured program design to procedure-oriented program design.
Non-structured Design Paradigm
Non-structured programming is historically earliest programming paradigm. A non structured program usually consists of sequentially ordered statements, usually one in each line. The lines are usually numbered or labeled to allow the flow of execution to jump to any line in program. There is no concept of procedures in non structured program; hence there are no independent reusable units in this programming paradigm. The program flow in non-structured programming would be as follows:
Figure: Program flow in Sequential Non Structured Programming
Example of code in non structured programming is:
INTEGER i
i=12
1 GOTO 10
2 CONTINUE i = i - 1
IF (i = 0) GOTO 99
10 PRINT*, "Line 10" GOTO 2
99 CONTINUE
The above fragment of code simulates a loop using GOTO statement for transfer of control. Note that the lines are labeled/ numbered so that they can be used with GOTO. The program executes the statements sequentially. The code simulates a loop to decrease the value of variable i by 1 till it reaches zero.
The initial value of i is 12. Until the value of i reaches zero, it continues to print the text ―Line 10‖.
Structured and Modular Design Paradigm
Structured design paradigm introduced the concept of selection and repetition of statements in code execution along with the line by line execution. It allowed writing of procedures and functions. These are the terms used for a block of code that is written to perform a single task. Procedures and functions were the beginning of compartmentalization and hence reusability of program code.
Procedures and functions which were for similar purpose were grouped together to get a module. A big software application consisted of multiple modules, each performing a particular task.
Structural design allowed modules to be reused in the form of code libraries.
Figure: Structured Programming with Procedure
As shown in Figure, same procedure is invoked from step 3 and step 4. There is also a selection of path to be followed. The two paths would be either steps 1,2,4 or steps 1,3.
The sample pseudo code for the above flow could be:
Object Oriented Design Paradigm
The next leap forward towards compartmentalization and reusability was arrival of object oriented-design that introduced the concept of an object as an atomic unit of functionality.
Object oriented design is built on the premise that programming problems can be modeled in terms of the objects in the problem domain. In this design, any object of interest in the real world is an object in the program code. This helps to effectively model the real world and interactions of items within it. As the objects in the real world interact with each other, similarly, the objects in the program interact through their interfaces or messages which are very well defined and contained in the objects. An object exposes the interface that can be called on by other objects that need the object's functionality. Because an object is a self-contained entity and because its interface is well-defined it is highly reusable across many applications.
For example, school and student are objects in real world. They would be considered as objects in object oriented design also and they would interact with each other through messages.
Figure: Object Oriented Programming
In the Figure each object has its own properties and methods which constitute the interface of the object.
Encapsulation is one of the basic principles of object-oriented programming
(OOP) and refers to an object's ability to conceal its data (properties) and methods. Encapsulated objects only publish the external interface so any user interacting with them only needs to understand the interface and can remain ignorant as to the internal specifications.
As the applications grew complex, code became more modular and reusable. The applications were being broken up into pieces that were distributed across many machines. Breaking applications into multiple parts and distributing them across multiple platforms presented a new set of reusability problems.
Component Based Paradigm
The concepts of Object Oriented paradigm were extended to component based programming. Component Based Development owes many concepts to object-oriented methods. It gives a more abstract view of software systems than object-oriented methods. This model prescribes that programming problems can be seen as independently deployable black boxes (components) that communicate through contracts.
The meaning of component or component based programming is intuitive: programs are broken down into primitive building blocks, which may be flexibly ―plugged together‖ according to well-defined protocols.
The idea behind component based programming is to develop software systems by assembling a set of independently developed components off-the-shelf (COTS) in a ‗plug and play' manner. For example, a Shopping cart website application may use off the shelf credit card authorization component.
Components exist at different sizes varying from single objects inside a library to whole applications. In most cases, however, components are larger entities and contain several objects.
Components are regarded as part of the starting platform for service-orientation – whereby a component is converted into a service.
Service Oriented Paradigm
Service-Oriented Programming builds on Object oriented programming, adding the premise that problems can be modeled in terms of the services that an object provides or uses.
A service is a unit of functionality defined by a set of message exchanges that are expressed using an implementation neutral grammar. It is a behaviour that can be implemented or provided by any component for use by any component based on message exchange.
A service, unlike an object, is an abstract entity whose implementation details are left largely ambiguous. The only implementation details spelled out are the messages the service exchanges or message exchanges. This ambiguity, coupled with the requirement that the messages be defined by an implementation neutral grammar make a service highly reusable and easy to integrate into a complex system.
Evolution of Programming Languages
As the software architecture moved from mainframes to Internet based and design paradigms evolved from non-structured to service oriented, Programming languages evolved to support the architecture and the design paradigms. As design became more and more compartmentalized so that the application could be distributed onto multiple machines, and individual components could be reused, more and more programming languages were designed to make support these ideas. For example COBOL is one language that evolved from procedural to object oriented.
Procedural Language
Procedural programming could also be called linear programming as one thing happens and then the next. Each instruction is executed in order from the top of the file to the bottom. It focuses on the idea that all algorithms are executed with functions and data that the programmer has access to and is able to change. Some languages which support procedural programming are C, FORTRAN, VB, etc.
Let us consider an example to understand how a procedural language works. You need to create forms for online inventory system for an automobile parts manufacturer. You are asked to design two separate forms: one to process information about cars and other about trucks.
For cars, we will need to record the following information:
Color
Engine Size
Transmission Type
Number of doors Make
For trucks, the information will be similar, but slightly different. We need:
Color
Engine Size
Transmission Type
Cab Size
Towing Capacity Make
We will code as follows:
/*Declare the Global variables*/
Var Color
Var EngineSize
Var Transmission Type
Var Make
MainProg()
Begin
If requested for car
Call CarProcedure()
If requested for Truck
Call TruckProcedure()
End
CarProcedure()
Begin
/*Declare the Local variables*/ Var NumberOfDoors
Process Car Information
End
TruckProcedure()
Begin
/*Declare the Local variables*/
Var CabSize
Var TowingCapacity
Process Truck Information
End
If we need to add form to process information for bus, then we need to change the MainProg() and add code for Bus Form. But if there is a change in the processing of all the vehicles, then we need to make changes to all the forms. If we need add any make specific information for cars, then we need to create multiple forms, one for each make. Also, we need to be careful about any changes to the global variables as all the forms are accessing them.
Object Oriented Language
Object Oriented Programming is more abstract than procedural programming because it looks for patterns and reusability. The same code can be loaded and executed many times to accomplish a task without having to retype it.
Before we consider above example in object oriented, let us understand few terms and concepts associated with object oriented programming. There are three main concepts that any language needs to support to be an object oriented language.
Encapsulation: is a mechanism through which a protective wrapper is created to hide the implementation details of the object and the only thing that remains externally visible is the interface of the object. (i.e.: the set of all messages the object can respond to). Encapsulation prevents code and data from being arbitrarily accessed by other code defined outside the wrapper.
Inheritance: is the process by which a new class is created using an existing class. It is a way to compartmentalize and reuse code since it allows classes to inherit commonly used state and behavior from other classes. The new classes are called the derived classed and the main class is called the parent class.
Polymorphism: Polymorphism is the characteristic of being able to assign a different meaning specifically, to allow an entity such as a variable, a function, or an object to have more than one form. It is the ability to process objects differently depending on their data types and to redefine methods for derived classes.
Following are the few terms that will help you understand object oriented programming:
A class is a set of functions that work together to accomplish a task. It can contain or manipulate data, but it usually does so according to a pattern rather than a specific implementation. An instance of a class is considered an object.
An object receives all of the characteristics of a class, including all of its default data and any actions that can be performed by its functions. The object is for use with specific data or to accomplish particular tasks. To make a distinction between classes and objects, it might help to think of a class as the ability to do something and the object as the execution of that ability in a distinct setting.
A method simply refers to a function that is encased in a class.
A parameter is a variable that is passed into a function that instructs it how to act or gives it information to process. Parameters are also sometimes called arguments.
A property is a default set of data stored in a class. A class can have multiple properties and the properties can be changed dynamically through the methods of the class.
Smalltalk, C++, Java, C# are some of the examples of object oriented languages. Now let us see how we create classes and use them for the automobile parts inventory management system example.
Class Vehicle {/*Data*/
Var Color
Var EngineSize
Var TransmissionType Var Make
/*Methods for each data*/ Color()
{
Store and update color;
}
EngineSize()
{
Store and update EngineSize;
}
TransmissionType()
{
Store and update TransmissionType;
}
Make()
{
Store and update Make;
}
}
Class Car Inherits Vehicle {/*Data*/
Var NumberOfDoors
/*Methods*/
NumberOfDoors()
{
Store and update NumberOfDoors;
}
}
Class Truck Inherits Vehicle {/*Data*/
Var CabSize
Var TowingCapacity
/*Methods*/ CabSize ()
{
Store and update CabSize;
}
TowingCapacity ()
{
Store and update TowingCapacity;
}
}
Now in this case, if we need to add form to process information for bus, then we just add one more class Bus() which is again inherited form the Vehicle class. And if we need add any make specific information for cars, then again we can add make specific classes which can be inherited from the Class Car() We need not worry about mistakenly modifying any global variables. If there is change in processing of all the vehicles, then instead of making changes at all the places, we just modify the Vehicle() class.
Evolution of Software Licensing
Software licensing has kept pace with the evolution of software solutions offered by the vendor or the solution provider community.
Introduction to Software Licensing
Until early 1970's, sharing of software was the accepted norm. Hardware came bundled with software products which could be freely redistributed and the access to source code allowed its improvement and modification.
In late 1960's, the situation changed after the software cost increased and manufacturers started to unbundle the software and hardware. A growing amount of software was now developed for sale. In late 1970's and early 1980's companies began imposing restrictions on programmers through copyright. They achieved financial gains by selling rights of use of software rather than giving the source code. This led to introduction of software licensing which governed the usage and redistribution of software. During this time most of the companies developed proprietary software that was actually the property of the company, came without the source code and the users basically bought the right to use it in the way specified under the license agreement.
In early 1980's the seeds for free and open software were sown as a deviation from the proprietary software. The open source software comes with source code and a license that allows modification and free redistribution.
We will study in the following section, about different types of licenses that evolved with software over the period of time.
Types of Software Licensing
The licensing type generally depends on whether the software is open source software, is meant for individual use or enterprise wide commercial use:
Individual License: allows you to install the software only on a single stand alone machine. It may be a perpetual license or Subscription based. Perpetual license allows you to install and use the software indefinitely. Subscription based license allows you to use the license for the specified time, after which you may renew the subscription or remove the software.
Open Source License: It grants you the right to freely modify and redistribute the software.
Commercial License: These are mostly for the large enterprises that use software for commercial purposes.. Following are the main licensing models:
Traditional model : This includes single user-single license, multi users-shared license, temporary or fixed-period licenses. This has mostly been used for large proprietary mainframe applications.
Transaction-based model : Here, the pricing is based on providing a committed business service, for ex, processing payroll for a global company as part of HR offering and this can be priced per employee. Larger the employee base at a given location, lower the price / employee can be. This model came into existence with the evolution of software architecture from mainframes to internet based. As mentioned before, when a company provided a particular business service, its client could access the system from anywhere over the Internet and they need not bother about maintaining the database or the software system. The service provider then charges them for each transaction/ record processed through their system.
Rental model : This has come into picture as Software as a Service (SaaS) and Platform as a Service (PaaS) models have evolved over a period of time. Here, the buyer need not need make upfront investment in hardware and software, rather these come as bundled service to them. Few examples where these are prevalent are – Finance & Accounting (Core Finance), Human Resources (Core HR), Analytics (Business Intelligence/Reporting), Procurement etc. There are also scenarios where the software vendor provides subscription of a given solution (ex. Windows Azure, Salesforce.com, Siebel On Demand, Amazon Web Services etc) on a periodic (ex. monthly, annual) basis.
Technology Partnerships : Such agreements provide the consumer un-limited access to vendor's technology. Such contracts are typically multi-year in nature where the consumer pays a fixed annual fee, which can be adjusted in the subsequent years based on the actual usage. For example, a large corporate customer deciding to use Oracle suite of ERP (Finance, HR), database, CRM, Business Intelligence/ Reporting solutions can get into a long-term multi-year partnership.
Check Your Progress 1
1. Compare and contrast the following:
a. Mainframe and File Sharing architecture
b. Client server and Distributed architecture
c. Structured and Non Structured Programming
a) In the Mainframe architecture all operations and functionality are contained within the central (or "host") computer. Users interact with the host through 'dumb' terminals which transmit instructions, by capturing keystrokes to the host and display the results of those instructions for the user.
File Sharing architecture is network (LAN) based where ‗intelligent' PC's or workstation's downloads files from a dedicated "file server" and then runs the application (including data) locally.
b) In Client Server architecture, the Client software requests for the service and Server software provides the service. The client and the server software may be on the same machine or two different networked machine.
In the distributed systems, different parts or components of an application run on different networked machines. There are set of standards that specify how different distributed components communicate.
c) In Structured programming statements are organized in a specific manner to minimize error or misinterpretation. It enforces logical structure of the program. Here large routines can be broken down into smaller, modular routines. It discourages GOTO statements.
Non Structured programming is the earliest programming paradigm in which program usually consists of sequentially ordered commands, or statements, usually one in each line. It does not enforce any logical structure of the program. Its needs discipline on programmers part to write readable and understandable code. Here the whole code is written in one module. It makes extensive use of GOTO statements that leads to spaghetti code.
2. Describe the following terms:
a. Software Reusability
b. Software Reliability
c. Encapsulation
a) Software Reusability: Ability of a computer program to be used repeatedly with little or no modifications in many different applications. For example code to authenticate credit card information can be used at all the places where payment is through credit card.
b) Software Reliability: Ability of a computer program to perform its intended functions and operations for the specified period of time, in the specified system's environment, without experiencing any failure. The less there is breakdown of the system, the more reliable it is.
c) Encapsulation: Ability to hide data and methods from outside the world and only expose data and methods that are required. It helps in hiding all the internal details from outside world. It also provides a way to protect data from accidental corruption
3. What do you understand by Software-as-a-Service? How is it different from Cloud Computing?
Software-as-a-Service (SaaS) is basically a software delivery model where customers can use the software application as a service on demand and pay for it per usage. It is based on the concept of renting application functionality from a service provider rather than buying, installing and running the software yourself.
Cloud computing is the broader concept of using the internet to allow people to access the technology enabled services. Those services must be massively scalable' to qualify as true cloud computing'.
Cloud computing is basically what SaaS applications run on.
4. What is pay-per-use licensing?
With advances in networking technology, vendors began to introduce non-perpetual licensing models, such as subscription or pay-per-use licensing. In the pay-per-use, user is charged each time he/she uses the software, service or module and user does not own the software, rather uses it at on rent for the limited period. There is time based pay-per-use arrangement and transaction based pay-per-use arrangement.
In a time based pay-per-use arrangement, consumers are charged for the amount of time that they used non-owned copies of the software.
In a transaction based pay-per-use arrangement, usage charges occur because a software module has been used. The duration of use is irrelevant.
Enroll for Coaching or Home Class | IGNOU BCA MCA Solved Assignment 2016 2017 on process Join IGNOU BCA MCA Coaching Class | Synopsis & Project Support
ignou bca mca synopsis, ignou class, ignou bca mca project, solved ignou assignment,BCA Coaching Institute in Delhi, MCA Coaching Institute in Delhi, BCA MCA Coaching Institute in Delhi, BCA MCA, Tuation Class in delhi, IGNOU BCA MCA Class, IGNOU BCA MCA Tution,IGNOU Solved Assignment, IGNOU BCA Synopsis , IGNOU MCA Synopsis, ignou bca project, ignou mca project, ignou best coaching in delhi, ignou best coaching in new delhi, ignou best coaching in south delhi, ignou best coaching in north delhi, ignou best coaching in east delhi, ignou best coaching in west delhi
ignou, bca, mca, coaching institute, tution class, bcsp064, mcsp060, cs76, mcs044,bcs011, bcs012, mcs011, mcs012, mcs013, mcs015, bcsl021, bcsl022, mcs014, bcs040, mcs021, mcs023, bcs031, bcsl032, bcsl033, bcsl 034, bcs041, bcs042, mcsl016, bcsl043, bcsl044, bcsl045, bcs051, bcs052, bcs053, bcs054, bcs055, bcsl056, bcsl057, bcsl058, bcs062, mcs022, bcsl063, project
mcsp060, mcse011, mcse004, mcse003, mcsl054, mcs053, mcs052, mcs051, mcsl045, mcs044, mcs043, mcs042, mcs041, mcsl036, mcs035, mcs034, mcs033, mcs032, mcs031, mcsl025, mcs024, mcs023, mcs022, mcs021, mcsl017, mcsl016, mcs015, mcs014, mcs013, mcs012, mcs011
nips institute, nipsar, ignoufriend.in, ignoufriend.co.in, ignouhelp, best coaching institute
No comments:
Post a Comment