Computer Programming

COBOL, the COmmon Business Oriented Language, is considered one of the forerunners of modern programming. Designed in the 1950s, it was considered the most advanced language of its time. It was commonly programmed on punch cards, which were in common use before disk storage as an input medium for stored procedures. It also had constructs considered revolutionary at that time, including self-modifying code.

executable program

Yes.And it's free it's called a Text Document,once you write a command you just need to save it as ie:.txt .exe .startup .dll etc.

IN COMPUTER SCIENCE, A SPACE-TIME OR TIME-MEMORY TRADEOFF IS A SITUATION WHERE THE MEMORY USE CAN BE REDUCED AT THE COST OF SLOWER PROGRAM EXECUTION (OR, VICE VERSA, THE COMPUTATION TIME CAN BE REDUCED AT THE COST OF INCREASED MEMORY USE). AS THE RELATIVE COSTS OF CPU CYCLES, RAM SPACE, AND HARD DRIVE SPACE CHANGE HARD DRIVE SPACE HAS FOR SOME TIME BEEN GETTING CHEAPER AT A MUCH FASTER RATE THAN OTHER COMPONENTS OF COMPUTERS. THE APPROPRIATE CHOICES FOR SPACE-TIME TRADEOFFS HAVE CHANGED RADICALLY. OFTEN, BY EXPLOITING A SPACE-TIME TRADEOFF, A PROGRAM CAN BE MADE TO RUN MUCH FASTER.

THE MOST COMMON SITUATION IS AN ALGORITHM INVOLVING A LOOKUP TABLE: AN IMPLEMENTATION CAN INCLUDE THE ENTIRE TABLE, WHICH REDUCES COMPUTING TIME, BUT INCREASES THE AMOUNT OF MEMORY NEEDED, OR IT CAN COMPUTE TABLE ENTRIES AS NEEDED, INCREASING COMPUTING TIME, BUT REDUCING MEMORY REQUIREMENTS. A SPACE-TIME TRADEOFF CAN BE APPLIED TO THE PROBLEM OF DATA STORAGE. IF DATA IS STORED UNCOMPRESSED, IT TAKES MORE SPACE BUT LESS TIME THAN IF THE DATA WERE STORED COMPRESSED (SINCE COMPRESSING THE DATA REDUCES THE AMOUNT OF SPACE IT TAKES, BUT IT TAKES TIME TO RUN THECOMPRESSION ALGORITHM). DEPENDING ON THE PARTICULAR INSTANCE OF THE PROBLEM, EITHER WAY IS PRACTICAL. ANOTHER EXAMPLE IS DISPLAYING MATHEMATICAL FORMULAE ON PRIMARILY TEXT-BASED WEBSITES, SUCH AS WIKIPEDIA.

Storing only the LaTeX source and rendering it as an image every time the page is requested would be trading time for space - more time used, but less space. Rendering the image when the page is changed and storing the rendered images would be trading space for time - more space used, but less time. Note that there are also rare instances where it is possible to directly work with compressed data, such as in the case of compressed bitmap indices, where it is faster to work with compression than without compression. Larger code size can be traded for higher program speed when applying loop unrolling. This technique makes the code longer for each iteration of a loop, but saves the computation time required for jumping back to the beginning of the loop at the end of each iteration. Algorithms that also make use of space-time tradeoffs include:

BABY-STEP GIANT-STEP ALGORITHM FOR CALCULATING DISCRETE LOGARITHMS.

RAINBOW TABLES IN CRYPTOGRAPHY, WHERE THE ADVERSARY IS TRYING TO DO BETTER THAN THE EXPONENTIAL TIME REQUIRED FOR A BRUTE FORCE ATTACK. RAINBOW TABLES USE PARTIALLY PRECOMPUTED VALUES IN THE HASH SPACE OF A CRYPTOGRAPHIC HASH FUNCTION TO CRACK PASSWORDS IN MINUTES INSTEAD OF WEEKS. DECREASING THE SIZE OF THE RAINBOW TABLE INCREASES THE TIME REQUIRED TO ITERATE OVER THE HASH SPACE.

THE MEET-IN-THE-MIDDLE ATTACK USES A SPACE-TIME TRADEOFF TO FIND THE CRYPTOGRAPHIC KEY IN ONLY 2N + 1 ENCRYPTIONS (AND O(2N) SPACE) VERSUS THE EXPECTED 22N ENCRYPTIONS (BUT ONLY O(1) SPACE) OF THE NAIVE ATTACK.

DYNAMIC PROGRAMMING, WHERE THE TIME COMPLEXITY OF A PROBLEM CAN BE REDUCED SIGNIFICANTLY BY USING MORE MEMORY.

RAM is volatile storage, short-term storage or working memory. As opposed to a hard-drive which is non-volatile, long term storage or a mass-storage medium.

A list is an abstract data structure, usually defined as an ordered collection of data. A linked list refers to a specific implementation of a list in which each element in the list is connected (linked) to the next element.

InsertNode(NODE **q,int num)

{

NODE *r,*temp ;

temp = *q;

r= malloc(sizeof(NODE));

r->data = num;

//if it's fisrt node to be inserted

if ( *q == NULL num < (*q)->data)

{

*q = r ;

(*q)->link=temp;

}

else

{

while(temp)

{

if ( (num > temp->data) && (num < temp->link->data ) )

{

r->link = temp->link;

temp->link = r;

return;

}

temp = temp->link;

}

r->link = NULL;

temp->link = r;

}

}

There is no uninstaller for an operating system. To remove an OS, simply format the partition that holds the operating system. If you use a boot manager to choose between different operating systems the software should automatically detect missing operating systems for you.

Only assembly languages are generally considered low-level programming languages, so one could argue that there is only one low-level language.

However, there are as many assembly languages as there are processor models or families, as each processor family implements its own set of machine code instructions. Different manufacturers not only invent different mnemonics for similar machine code operations to suit conventions and hardware architecture (e.g. MOVE vs LOAD/SAVE), but also support different notations.

Therefore, conceptually, the assembly language is the only low level programming language. However, the standpoint of view of learning the language, or from that of tools to support the language, there are numerous assembly languages, thus numerous low-level languages.

Because no-one knows what the sum of two pointers should be...
of course you can convert them to integers and then sum them, but why on earth would you do that?

False. OO programs are usually slightly bigger and slower than 'standard' programs.

#include<stdio.h>

#include<conio.h>

void main()

{

int i,j,temp,a[7];

clrscr();

printf("Enter 7 integer numbers: \n");

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

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

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

{

for(j=i+1;j<7;j++)

{

if(a[i]<a[j])

{

temp=a[i];

a[i]=a[j];

a[j]=temp;

}

}

}

printf("\n\nThe 7 numbers sorted in ascending order are: \n");

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

printf("%d\t",a[i]);

getch();

}

= How do you distinguish between data and information? = I THOUGHT DATA WAS THE OFFSPRING OF IMFORMATION, CONSIDERING DATA WOULD BE THE GATHERING OF INFORMATION. IT COULD SAID BE LIKE THIS: ALL THE INFORMATION YOU REQUESTED DATA ON HAS BEEN STORED IN YOUR HARD DRIVE, THEIR THE TWO TOGETHER IN ONE SETENCE. ON THE OTHER HAND DATA.. INDUCTIVE REASONING: A TREMENDOUS SEA OF INFORMATION.. YOU HAVE TO SEE ENOUGH, TO REMEMBER ENOUGH INFO TO PUT IT TOGETHER. I SAID THAT.... GENA

#include <stdio.h>

#include <conio.h>

void main()

{

int num,rev=0,m,r;

clrscr();

printf("enter any number");

scanf("%d",&num);

m=num;

while(num>0)

{

r=num%10;

rev=rev*10+r;

num=num/10;

}

if(rev==m)

printf("given number is palindrome");

else

printf("given number is not palindrome");

getch();

}

this is the answer.

Multiply miles by 1.609344 to get kilometres:

double mile2km (double miles) { return miles * 1.609344; }

Multiply kilometres by 0.62137119 to get miles:

double km2mile (double km) { return km * 0.62137119; }

Remember that a pointer is just a variable containing the memory address of another variable. A pointer to a pointer is no different, other than that the address contains the address of another pointer. You use the * indirection operator to get the value of the variable being pointed at (the address of the other pointer), and the ** indirection operator to get at the value pointed at by the other pointer.

The following example illustrates how to access the values of pointers to int via an array of pointers to those pointers.

The memory address and the value of every variable is displayed for the benefit of clarity.

#include <iostream>

using namespace std;

int main()

{

// Set up an array of pointers to pointers to int variables.

int X = 1, Y=2; // The actual variables.

int* pX = &X; // Pointers to those variables

int* pY = &Y;

int** pp[2]; // Array of pointers to those pointers.

pp[0] = &pX;

pp[1] = &pY;

// Print the address of all variables and their stored values:

cout << "Var\t&Address\tValue" << endl;

cout << "---\t--------\t-----" << endl;

cout << "X\t0x" << &X << "\t" << X << endl;

cout << "Y\t0x" << &Y << "\t" << Y << endl;

cout << "pX\t0x" << &pX << "\t0x" << pX << endl;

cout << "pY\t0x" << &pY << "\t0x" << pY << endl;

cout << "pp\t0x" << &pp << "\t0x" << pp << endl;

cout << endl;

cout << "Note that both &pp and pp return the same value: the address of the array." << endl;

cout << "pp is simply an alias for the memory allocated to the array itself, it is" << endl;

cout << "not a variable that contains a value. You must access the elements of the" << endl;

cout << "array to get at the actual values stored in the array." << endl;

cout << endl;

// Use the array elements to access the pointers and the values they point to:

cout << "Elem\t&Address\tValue\t\t*Value\t\t**Value" << endl;

cout << "----\t--------\t-----\t\t------\t\t-------" << endl;

cout << "pp[0]\t0x" << &pp[0] << "\t0x" << pp[0] << "\t0x" << *pp[0] << "\t" << **pp[0] << endl;

cout << "pp[1]\t0x" << &pp[1] << "\t0x" << pp[1] << "\t0x" << *pp[1] << "\t" << **pp[1] << endl;

cout << endl;

return( 0 );

}

Threads in distributed applications have the same benefits as in any other application: they allow you to perform multiple operations at the same time.

Specifically for distributed applications, the server will most definitely be multi-threaded so that it can communicate with all of the clients. The clients will also most likely have at least two threads: one for communication with the server and one for doing actual data processing.

some programmers think breaking the process into smaller parts allows them to better understand what the procedure being programmed does

Pseudocode is not a programming language (it's specifically intended for human interpretation), so there is no need to declare variables, you simply define them as and when you require them. For instance:

Let x = 42

Let y = x * 2

C was initially developed by Dennis Ritchie from 1969 to 1973. C++ was initially developed by Bjarn Stroustrup from 1979 (when it was known as C with Classes) to 1983 (when it was renamed C++). Both developers worked at Bell Labs at the time.

It depends.

If you are using unsigned numbers, then the following assumption is made:

0b11 = 0b00000011,

in which case the answer is;

2^1 + 2^0 = 2 + 1 = 3

If you are using signed numbers, than a binary number in the form 0b11 would be interpreted as negative because the leading bit is equal to 1. For signed numbers, the '1' in the leading bit is extended, thus:

0b11 = 0b11111111

In order to interpret this number, negate the number by flipping the bits and adding 1:

0b11111111

0b00000000 (bits flipped)

0b00000001 (added one)

The positive representation of 0b11111111 is equal to 0b00000001, which is equal to 1, thus

0b11 = 0b11111111 = -1

FORTRAN, Assembler, to name two. Effectively, any language that allows you to reference symbols before they are declared.