Computer Programming

Most modern programming languages have some support for object-oriented programming. In some (such as Java), it is obligatory - you have to write your code in classes. In others - such as JavaScript or PHP - it is optional, meaning that you can write programs the old-fashioned way (procedural programming).

Actually, there is not that much attention today paid to object-oriented programming. It is not a new technology. It is more than 15 years old, and the design paradigm of object-oriented design and object-oriented programming is relatively well established.

Where the attention today is focused is more on multi-threaded programming. The reason for this is that today's processors are approaching the point where Moore's Law is starting to flatten out, i.e. we are approaching the limits of performance gains in a single processor as technology advances.

Many modern computers solve this problem by having more than one processor. Some have many, even thousands or more, such as in a modern supercomputer. The problem is that it is very difficult to write algorithm's that can adequately take advantage of that parallelism. We tend to think linearly, and our algorithms follow that thinking. Such a linear process, however, can only use one processor at a time. We need to work on algorithms that can utilize all of the available processors in a computer at the same time.

Two "yesterdays" ago, the challenge was Block Structured Programming. One "yesterday" ago, the challenge was Object Orientation. "Today", the challenge is Multi-Threading.

1.start

2.a=0,b=1,c and counter

3.display a

4.display b

5.c=a+b

6.display c

7.a=b

8.b=c

9.check whether number is less than the last number you have

if yes than go to step 5

if no stop it

Object Oriented Programming is the technique to create programs based on the real world..object oriented programming model programs are organized around objects and data rather than actions and logic. In OOP based language the principal aim is to find out the objects to manipulate and their relation between each other.OOP offers greater flexibility and compatibility and is popular in developing larger application.

Computers with more RAM can handle more information without crashing. Computers have to store all of the data coming from all the the devices in the computer until the processor can process the data and this data is stored in the RAM. If you have small amounts of RAM, it will fill up and then all the devices pause until the RAM has more room for data. So the more RAM that a computer has the less waiting the devices have to do on account of the CPU having data already waiting to be processed. daman155 In most modern systems using Windows XP, Linux, etc.. more RAM is better. This enables the system to keep more applications and data such as documents spreadsheets and Internet pages in the systems main storage area, which is RAM. When you have more applications and data loaded than can fit into RAM, the system will remove what it sees as idle data not being immediately used and move it from ram to "Virtual Memory" on your hard disk. This "Virtual Memory" or Swap Space is VERY SLOW. This means when you go back to what was deemed idle memory, it takes awhile to swap back into RAM. So unless you run out of both RAM and disk space, you may not crash, but without more RAM you will not be able to open as many applications or documents as you may like. --Veggivore--

Generally, the first step in learning to program is to understand the process of editing code, compiling the software and running the subsequent program.

10 SCREEN 2

20 PSET (200,120)

30 DRAW "E100 F100 L200"

40 PSET (200,50)

50 DRAW "R200 G100 H100"

END

Data deduplication is the method by which you can prevent data duplication. Data deduplication is a specialized data compression technique for eliminating coarse-grained redundant data, typically to improve storage utilization. In the deduplication process, duplicate data is deleted, leaving only one copy of the data to be stored, along with references to the unique copy of data. Deduplication is able to reduce the required storage capacity since only the unique data is stored.

napthalene has got double ring system having alternate doublebond

To "mark up" means to determine the look and structure of a text (font type, size, color).

The transition to a "programming language" is theoretically fluent - but generally a markup language is to determine how things look, and a programming language is to determine how things react to user actions.

When websites are "interactive" - for example, if they contain games, or movable sub-windows or small text-editors - this is realized not with HTML, but with Javascript or Flash or Java, which are separate formats that can be integrated in HTML. They themselves are programming languages, HTML is not.

Well do you mean for the purposes of research and development? To process, create, and display numerous things to complicated for most minds. Like DNA sequencing, development of drugs and treatments, logging large numbers of test studies.

For more mundane things, to keep track of patient records, take x-rays, see things we can't, some forms of remote surgery.

A great many things more as well. Please be more specific to receive more relevant help.

#include<stdio.h>

#include<string.h>

void main()

{

char str[50];

char ext[50];

int pos,len,i,j=0;

printf("\nenter the main string.....-\n");

gets(str);

printf("\nenter the position and length of the string to be extracted...-\n");

scanf("%d%d",&pos,&len);

for(i=pos-1;i<len+pos;i++)

{

ext[j++]=str[i];

}

puts(ext);

}

/* this is a much easier solution by : ROHIT VERMA*/

SQL

These are the main categories are

DDL(Data Definition Language)

DML ( Data Manipulation Language)

DQL( Data Query Language)

DCL( Data control Language)

Data administration commands

Transactional control command.

ddl includes insert ,delete ,update values

it include select statements,

it include insert statement,

it includes drop statements

The traditional way to learn any programming language is to start by writing a "Hello, World" program; this program should write "Hello, World" to the screen. To write such a program, you have to work out how to edit text, and run it through the compiler. Visual Basic, is almost like that, but window environment programs are event driven - they consist of routines that react to events - a button being clicked, a timer expering and so on. Visual Basic is also object orientated. Windows, buttons, every component of a program are objects or part of objects. With this in mind, its useful to read up on events and objects to see how to approach Visual programming. With a little knowledge, think of a project and try and write a program. Writing programs is by far the quickest way to become proficient in a language.

means whether the matrix is same or not

program for symmetric matrix :

include<stdio.h>

#include<conio.h>

main()

{

int a[10][10],at[10][10],k,i,j,m,n;

clrscr();

printf("enter the order of matrix");

scanf("%d %d",&m,&n);

printf("enter the matrix");

for(i=0;i<m;i++)

{

for(j=0;j<n;j++)

scanf("%d",&a[i][j]);

}

for(i=0;i<m;i++)

{

for(j=0;j<n;j++)

at[i][j]=a[j][i];

}

for(i=0;i<m;i++)

{

for(j=0;j<n;j++)

{

if(at[i][j]!=a[i][j])

k=1;

}

}

if(k==1)

printf("not symmetric");

else

printf("symmetric");

getch();

}

The spell check is one of most used computer programs or modules. It has made us not to do the spell check ourselves.

Im looking for that answer as well, but you need some advanced math for expressions and algebra. Also, alot of patience >.< In fact, I just started programming in C++. If you read alot of guides, theres not really need for lots of education. Im reading some really good free online guides at the moment... If you plan on learning C++, i suggest reading these guides... http://msdn.microsoft.com/nb-no/beginner/cc305129(en-us).aspx (on the right side of the page) So far for me, theres been no need for advanced maths. Hope this helped ;)

arrays are used to store the group of data which are of same type.

These arrays can be applied in student mark sheet applications,online library applications etc.

Documentation is critical unless you are the only person who will ever, ever, ever look at a piece of code. And even then, if you go away from it for 6 months you will probably have trouble remembering what you did.

In business, code MUST be commented because the person fixing or enhancing the program is often not the person who wrote it. It can take 4 or 5 times as long to figure out what a program is doing when you only have the computer-language logic available, as opposed to an English-language explanation of the underlying concepts.

It's also critical to keep the documentation up to date and accurate in both facts and spelling. If the code has been changed and the documentation hasn't, that disagreement can mislead anyone who comes along and tries to work on the code later. If you can't spell or use lousy grammar, it can make it a lot harder to perform text searches looking for a particular phrase that's likely to appear in a comment. Try searching for PARAMETER when somebody spelled it PARAMATER, for example (I've had to do just that!!)

The above is an explanation to why documentation is important in one of levels of software documentation - Technical or Code Documentation. There are other levels of documentation including Software Requirements Documentation, Software Architectural/Design Documentaion and End-User Documentation (e.g.: Manuals, Tutorials). Documentation at each of these levels is usually necessary, or at least desired, for most non-trivial software projects. For more information on these levels of documentation and to who and how it may be important, pls see http://en.wikipedia.org/wiki/Software_documentation

The main advantage of real-time processing is that you will get results immediately. This will allow one to make quick decisions before too much time is wasted as they are able to monitor the process in real time.

lolo mo, lola mo, anty mo, uncle mo.

An array is simply a contiguous allocation of one or more elements of a given type.

int i; // a single element of type int

int j[100]; // an array of 100 elements of type int

The elements of an array are anonymous (we can't refer to them by name because they have no names). However we can access them by their offset address from the start of the array. The array name serves as a reference to the start of the array and will implicitly convert to a pointer:

int* p = j;

Each element of an array is offset by sizeof (type) bytes. However, the offset is known to the compiler so we do not need to specify it when accessing array elements, we only need to know the zero-based index of the element we wish to access:

int k = j[42];

Note that the suffix operator [] does not perform a range-check. It is up to the programmer to ensure the given index is in range. The array named j has 100 elements so all indices must be in the range 0 through 99. Access beyond the range of an array has undefined behaviour:

int m = j[100]; // undefined behaviour

Given j is a reference, we can also use pointer arithmetic to access elements:

int n = j + 42;

From this we can see that the following holds true:

j[42] 42[j]

It often surprises people to learn that j[42] and 42[j] are equivalent, however it's only because the suffix operator is sugar-coating for the underlying pointer arithmetic so the compiler sees 42 + j, not 42[j]. However, low-level trickery such as this has no place in production code.

The elements of an array are uninitialised at the point of instantiation. However we can use an initialiser to set initial values:

int j[5] = {5, 10, 15, 20, 25};

When we pass arrays to functions, the array implicitly converts to a pointer. This means information is lost in the exchange because the function cannot know how many elements are being referred to by the pointer. Thus we must pass the length of the array as a separate argument:

void f (int* arr, unsigned size) {

for (unsigned idx=0; idx<size; ++idx) {

arr[idx] = 0;

}

}

Given that arrays implicitly convert to pointers, variable-length arrays are treated exactly the same as fixed-length arrays, the only difference is that the programmer is responsible for allocating and releasing the memory:

void g (unsigned size) {

int* p = malloc (size * sizeof (int)); // allocate

f (p, size); // use

free (p); // release

}

Note that variable-length arrays cannot be initialised at the point of instantiation; they must be instantiated then initialised, as shown above.

Fixed-length arrays (where the length is known to the compiler) can be allocated in static memory, on the call stack or on the heap. Global arrays are best allocated statically while small local arrays are best allocated on the stack. Large local arrays should be allocated on the heap. Variable-length arrays must always be allocated on the heap.