Software Engineering

An instrument such as a hammer, saw, plane, file, and the like, used in the manual arts, to facilitate mechanical operations; any instrument used by a craftsman or laborer at his work; an implement; as, the tools of a joiner, smith, shoe-maker, etc.; also, a cutter, chisel, or other part of an instrument or machine that dresses work., A machine for cutting or shaping materials; -- also called machine tool., Hence, any instrument of use or service., A weapon., A person used as an instrument by another person; -- a word of reproach; as, men of intrigue have their tools, by whose agency they accomplish their purposes., To shape, form, or finish with a tool., To drive, as a coach.

student

Low coupling

OMT is a modelling technique and UML is a Modelling language. OMT stands for object modelling technique and is given by Jim Rambaugh . UML is unified Modelling language and has a layered architecture.

single variable is a that variable which works witout the interaction of other.it does not concern with any other variable

verification: Are we doing the right system?

validation : Are we doing the system right?

malware

The requirements for a prototype typically include a clear definition of the problem it aims to solve, specifications of the desired features and functionality, and the materials or resources needed for its construction. Additionally, it should have a defined scope, including any constraints such as budget and time limits. Finally, user feedback mechanisms should be in place to evaluate its effectiveness and guide future iterations.

i dont know

; ticking-box testing : a widely used philosophy of testing, in which no testing is done after the project is fairly well debugged -- the program is given to customer's for trial and acceptance (Robert Kruse)

spiral model and prototype model

Generally G codes are writen in and performed by the CNC processor and operate the motion control part of the control, the M codes are MACHINE codes, these operate most of the basic electrical control functions such as Coolant, Tool changers, safety circuits etc, the M,S & T codes are written in a separate PLC processor, both processors usually communicate with each other over a common bus.

The tool changer and spindle are both configured to suit a particular machine specifics.

haha no1 knows

Some software engineers work in one place, but many will work in various locations and so will have to travel.

A page fault occurs. The service routine chooses a page to use. If that page is dirty, i.e. has been written to and needs to be saved, then it is written to the page file. Then the new saved copy is loaded from either the page file or from the executable file. The page registers are updated, and the faulting instruction is retried.

In C++, names are either statically bound at compile time, dynamically bound at runtime or (with compile time computation) not bound at all.

With respect to functions, dynamic binding only occurs when a function is invoked through a function pointer. This also applies to virtual functions because the virtual function table (vtable) is simply a list of function pointers that apply specifically to the runtime class of the object the function is invoked against. If we do not know the runtime type (the actual type) of an object at compile time, then we cannot statically bind a virtual function call at compile time. Instead, the compiler must generate code to perform a vtable lookup and then invoke the appropriate function dynamically. However, if the runtime type is known at compile time, then we can statically bind to a virtual function.

Static binding is faster than dynamic binding because we eliminate the indirection required to invoke a function via a pointer variable. Although we can write code to determine the runtime type of an object and thus statically bind all function calls, the overhead far outweighs the otherwise trivial cost of an indirection.

In the case of recursive functions, dynamic binding can only occur if we invoke the function through a function pointer. Once invoked, all recursive calls to that same function are statically bound:

unsigned object::fact (unsigned x) {

return x<2 ? 1 : x * (fact (x-1));

}

Here, the name fact used within the function is implicitly bound to this->fact and is therefore statically bound to object::fact. The initial invocation may or may not have been dynamically bound, but that has no bearing once the function is invoked.

If a function is declared constant expression (constexpr) and is used in a constant expression, the function call (and its binding) can be eliminated completely. Consider the following:

constexpr unsigned fact (const unsigned num) {

return num < 2 ? 1 : num * fact (num - 1);

}

void f () {

unsigned x = fact (7);

// ...

}

A good compiler will replace all of the above with the following:

void f () { unsigned x = 5040;

// ...

}

This is known as compile-time computation. We get the convenience of a function (even a recursive one) but with none of the runtime cost. And since the function is not required at runtime, there is nothing to bind to. However, constant expression functions are useful in that they can also be used in expressions that are not constant. For example:

void g (unsigned x) {

unsigned y = fact (x);

// ...

}

The above call to fact cannot be computed at compile time because x is not constant, so the compiler must statically bind the function instead. Thus we get the advantage of compile time computation when it is possible to do so and static binding when it is not.

If we wish to prevent static binding completely, then we need to use template metaprogramming instead:

template<unsigned N>

constexpr unsigned fact() {

return N * fact<N-1>();

}

template<>

constexpr unsigned fact<1>() {

return 1;

}

template<>

constexpr unsigned fact<0>() {

return 1;

}

Note that we must use specialisation to handle the end cases (where N is 0 or 1). It is not as elegant as the plain constexpr version, however it does guarantee that we only use compile time computation rather than static binding:

void h (unsigned x) {

unsigned y = fact<7>(); // OK: generates equivalent code to unsigned x = 5040;

unsigned z = fact<x>(); // error: x is not constexpr

// ...

}

They are essentially the customers. They are the people that will have to use the software being developed. They need to be able to express their opinions on what they are getting. They need to advise the developers and point out any problems they have with the system as it is developed. They can point out mistakes that the developers are making. If they are not involved, then the system that the developers produce is less likely to meet the requirements of the users. The users will find it harder to use. They will have no preview of the system. A lot of the problems they will find then, could have been fixed much earlier if they were involved. This would save time and money for the development process. Users may feel a system is being imposed on them if they have no input into its development. So for all of these and other reasons, it is important that they are involved.

#include<iostream.h>

#include<conio.h>

#include<process.h>

#define SIZE 10

int queue[SIZE];

int front=-1,rear=-1;

void insert();

void del();

void display();

void main()

{

int ch;

do

{

clrscr();

cout<<"\nMAIN MENU."<<endl;

cout<<"\n1. Insert."<<endl;

cout<<"\n2. Delete."<<endl;

cout<<"\n3. Display."<<endl;

cout<<"\n4 Exit.\n"<<endl;

cout<<"\nEnter your choice.(1-4) : ";

cin>>ch;

switch(ch)

{

case 1 : insert();

break;

case 2 : del();

break;

case 3 : display();

break;

case 4 : exit(0);

default : cout<<"\nInvalid Choice.";

}

getch();

}

while(1);

}

void insert()

{

int val;

if(rear==SIZE-1)

{

cout<<"OVERFLOW."<<endl;

return;

}

cout<<"\nEnter the value : ";

cin>>val;

if(rear==front)

{

rear++;

front++;

queue[rear]=val;

}

else

{

rear++;

queue[rear]=val;

}

}

void del()

{

if(front==-1)

{

cout<<"\nQueue is empty.";

return;

}

if(front==rear)

front=rear=-1;

else

front++;

}

void display()

{

int front_vir=rear;

if(front==-1)

{

cout<<"\nQueue is empty.\n";

return;

}

while(front_vir<=rear)

{

cout<<queue[front_vir]<< " ";

front_vir++;

}

}

Stegnography is defined as the art of hiding information, data or messages in an image. Even the different file formats can be used for the purpose of hiding the information like for example the video or audio etc. The purpose is to pass on the information with out any regard or knowledge of others safely to the destination. The advantage of stegnography is that those who are outside the party even do not realize that some sort of communication is being done.

You will either get a mine, number or it will stay blank. GOOD LUCK

Background of the Study :

Why did you conduct the study?

States the rationale of the study. It explains briefly why the investigator chose this study to work on.

While testing an application, we try to see if a certain set of requirements are met by the application or not. But, when it comes to a user facing site then apart from concentrating on functionality software testing services provider have to look into few usability features, performance and security involved with the application.

Let's take an example of a loan management site, with functionality perspective we look whether the new customers able to apply the loan or not.

We need to test ease of using the site too. For example - if a user has to go through 2-3 pages just to fill the basic information then it is possible that they may get annoyed. So, such issues should also be addressed.

Testing the performance of site completely might not be in scope but we can test few areas to check its performance at peak hours. Similar the case with sites where secure access is involved we can test whether the application gets auto-logout successfully or not if the site remains idle for particular time period (say: 10 minutes).

In this way, we can easily figure out how important it is when it comes to user facing site.

Hope this information is helpful for you.

The Linear sequential model suggests a systematic sequential approach to software development. That begins at the system level and progresses through analysis, design, coding, testing, and support.

Smoke testing will be conducted to ensure whether the most

crucial functions of a software work, but not bothering

with finer details.

A Sanity test is used to determine a small section of the application is still working after a minor change. Smoke Testing: Smoke testing is nothing but to test the functionality of the software once build is done. Sanity testing: Sanity testing is nothing but to test the existing behaviour of an application, environment check up before starts execution.

This is a term from Object Oriented Programming. It refers to the ability of a function or procedure to accept and correctly process parameters of different Types declared in different Classes. It requires an ability to perform what is called runtime dispatching to call the correct actual function or procedure declared within the matching Class, out of all possible Classes.