FinaL Question:

#include
main()
{
int x,y;
clrscr();
gotoxy(1,1);
printf("Jhoy");
for(x=1;
x<=74; x++) { gotoxy(x,1); printf(" Jhoy"); delay(10000); } for(y=1; y<=24; y++) { gotoxy(75,y); printf("Jhoy"); delay(10000); gotoxy(75,y); printf(" "); } gotoxy(74,24); printf("jhoy"); for(x=77; x>=1; x--)
{
gotoxy(x,24);
printf("Jhoy ");
delay(10000);
}
for(y=24; y>=1;
y--)
{
gotoxy(1,y);
printf("Jhoy");
delay(10000);
gotoxy(1,y);
printf(" ");
}
gotoxy(1,1);
printf("jhoy");
getche();
}

Question # 5:

Answer:

1.Macros

Many assemblers support macros, programmer-defined symbols that stand for some sequence of text lines. This sequence of text lines may include a sequence of instructions, or a sequence of data storage pseudo-ops. Once a macro has been defined using the appropriate pseudo-op, its name may be used in place of an mnemonic.
Macro assemblers often allow macros to take parameters. Some assemblers include quite sophisticated macro languages, incorporating such high-level language elements as optional parameters, symbolic variables, conditionals, string manipulation, and arithmetic operations, all usable during the execution of a given macros, and allowing macros to save context or exchange information. Thus a macro might generate a large number of assembly language instructions or data definitions, based on the macro arguments. This could be used to generate record-style data structures or "unrolled" loops, for example, or could generate entire algorithms based on complex parameters. An organization using assembly language that has been heavily extended using such a macro suite can be considered to be working in a higher-level language, since such programmers are not working with a computer's lowest-level conceptual elements.

http://en.wikipedia.org/wiki/Assembly_language#Assembly_language

Question # 4:

Justify what situations or applications programmers will rather use Assembly Languages than Higher Level Progamming Languages and vice versa.

Answer:
For me, the Assembly language uses easy-to-remember commands that are more understandable to programmers than machine-language commands. Each machine language instruction has an equivalent command in assembly language. For example, in one Intel assembly language, the statement “MOV A, B” instructs the computer to copy data from location A to location B. The same instruction in machine code is a string of 16 0s and 1s. Once an assembly-language program is written, it is converted to a machine-language program by another program called an assembler.
Assembly language is fast and powerful because of its correspondence with machine language. It is still difficult to use, however, because assembly-language instructions are a series of abstract codes and each instruction carries out a relatively simple task. In addition, different CPUs use different machine languages and therefore require different programs and different assembly languages. Assembly language is sometimes inserted into a high-level language program to carry out specific hardware tasks or to speed up parts of the high-level program that are executed frequently.

And for the High-level languages were developed because of the difficulty of programming using assembly languages. High-level languages are easier to use than machine and assembly languages because their commands are closer to natural human language. In addition, these languages are not CPU-specific. Instead, they contain general commands that work on different CPUs.

Microsoft ® Encarta ® 2006.

Question # 3:

Answer:
x86-64

For me, the best assembler is the x86-64 becausethe x86-64 is a 64-bit superset of the x86 instruction set architecture. Because the x86-64 instruction set is a superset of the x86 instruction set, all instructions in the x86 instruction set can be executed bycentral processing unit (CPUs) that implement the x86-64 instruction set; therefore these CPUs can natively run programs that run on x86 processors from Intel, Advanced Micro Device (AMD), and other vendors.
x86-64 was designed by AMD, who have since renamed it AMD64. It has been cloned by Intel under the name Intel 64 (formerly known as EM64T and other names). This leads to the common use of the names x86-64 or x64 as more vendor-neutral terms to collectively refer to the two nearly identical implementations.
x86-64 should not be confused with the Intel Itanium architecture, also known as IA-64, which is not compatible on the native instruction set level with the x86 or x86-64 architecture.

http://en.wikipedia.org/wiki/X86-64

Question # 2:

ANSWER:
Historical perspective

Historically, a large number of programs have been written entirely in assembly language. Operating systems were almost exclusively written in assembly language until the widespread acceptance of C in the 1970s and early 1980s.
Most early microcomputers relied on hand-coded assembly language, including most operating systems and large applications. This was because these systems had severe resource constraints, imposed idiosyncratic memory and display architectures, and provided limited, buggy system services. Perhaps more important was the lack of first-class high-level language compilers suitable for microcomputer use.
Typical examples of large assembly language programs from this time are the MS-DOS operating system, the early IBM PC spreadsheet program Lotus 1-2-3, and almost all popular games for the Atari 800family of home computers. Even into the 1990s, most console video games were written in assembly, including most games for the Mega Drive/Genesis and the Super Nintendo Entertainment System. According to some industry insiders, the assembly language was the best computer language to use to get the best performance out the Sega Saturn, a console that was notoriously challenging to develop and program games for
The Assembler for the VIC-20was written by Don French and published by French Silk. At 1639 bytes in length, its author believes it is the smallest symbolic assembler ever written. The assembler supported the usual symbolic addressing and the definition of Character String or hex strings.

http://en.wikipedia.org/wiki/Assembly_language#Assembly_language

Question #1:

Question: What topic(s) in MCs 213 do you find easy and/or difficult and why?

Answer: The topic in MCS 231 that I find easy, for me is about blogging because eventhough it is my first time in blogging, to make it, you just follow the instructions given to make your own blog. And the topic in MCS 213 that I find difficult is about programming because im not really good in analyzing programming statements in c++..

Student Name: Marie Joy C. Bugas

heloOo thEre.!

juSt waNa saY hi....