偶看新闻舰c夕立装备:programm languizhi
来源：百度文库 编辑：偶看新闻 时间：2024/05/03 01:34:34
Understanding the different coding languages: Part #1
=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?
by cOrRupt G3n3t!x
So you want to be the best virus writer? But a VXer is only as good as the tools he uses and most importantly the language he programmes in and ofcourse the mind he was blessed with lol.
TYPES OF PROGRAMMING LANGUAGES:
-------------------------------
In a very broad term we have 5 types of programming languages:
1)First generation languages (abbreviated as 1GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*い*?*?*?*?*?*?*?*?
These are very primitive computer languages. It refers to 1's and 0's-Binary code-Which is the actual language that the computer understands (Machine code/language).The symbol 0 stands for the absence of Electric pulse and 1 for the presence of an electric pulse Programmers of the early 1950's, notably UNIVAC I and IBM 701, used machine language programs. Originally, no translator was used to compile or assemble the 1GL. The first-generation programming instructions were entered through the front panel switches of the computer system. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer.
Example code - Machine code:
?
10110000 01100001
?
Example code - Binary code:
?
B0 61
?
Example code - Binary code:
?
MOV AL, 61h ; Load AL with 97 decimal (61 hex)
?
2)Second generation languages (2GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
Next on the plate is 2GL languages also known as assembly languages. The code written in assembly languages are then converted to 1GL languages via a compiler. The programming language of assembly was a great step ahead that of 1GL languages as they now used symbolic names instead of numbers/binary code and evolved to include the use of macro instructions. This happened in the early-to-late 1950s. although assembly is not to different in its variations we have TASM, MASM,NASM and FASM syntaxes whixh are mainly just differents ways of moving variables etc i.e 'mov eax,[ecx]' in FASM and the equivalent in MASM would be 'mov eax,ecx'. So the variations are little to none.
?
;Example code - MASM32 Syntax:
mov ecx, 6 ; ecx=6
mov eax, 2; eax =2
add eax, ecx ;6+2
push eax
pop mt
cmp mt,8;8=8
jz oo ;jump if 0
ret ;return
oo:
invoke ExitProcess,0 ;exit
?
3)Third generation languages (3GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
In the 3GL of languages words and commands formed the syntax of the language rather than symbols and numbers. These were later dubbed known as "high level languages" and include C, C++, Java, VBS, JavaScript, BASIC and Delphi among many others.
?
//Example code - C# syntax:
while (true)
{
Process[] enumerateProcess = Process.GetProcesses();
foreach (Process process in enumerateProcess)
{
if (process.ProcessName.Equals("iexplorer.exe"))
{
Console.WriteLine("InternetExplorer IS ALIVE");
}
}
}
?
4)Fourth generation languages (4GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
The 4GL sees us coming closer to a human understandable language much like a sentence which holds more meaning than a command. these languages include, SQL, ColdFusion, FOCUS and MATLAB's GUIDE among others.Example code:
?
EXTRACT ALL CUSTOMERS WHERE "PREVIOUS PURCHASES" TOTAL MORE THAN $1000
?
5)Fifth generation languages (5GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
These languages are currently being used for neural networks. A nueral network is a form of artifical intelligence that attempts to imitate how the human mind works.It is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer.Examples are Prolog, OPS5, and Mercury.
Example code: right now imlementation is on the visual side of things such as drag and drop of hierarchy classes etc forming the basis.
SCRATCHING 'EM:
---------------
With the above in mind, we can now look at which are our best options. Well let me tell you 2GL and 3GL.
Why you may ask?
Well due to the sheer complexity of 1GL languages i.e manually calculating adresses, offsets, memory locations etc, make it an unlikely choice, and lets not start on the portability!
Next would be the 4GL language, and although it is possible to write viruses for/in it is not considered to be a great platform for virus writing. Viruses may write malicious code to 4GL languages however it is not possible to implement copy function etc in the language its is more an add on so learnong the syntax will increase your potential in virus writing but definitely not be benificail to learn by itself.
Lastly there is 5GL... Well find me a language that is truely 5GL and not some 4GL+EXTRA's and we can talk. But imagine a virus that can 'think' for itself :)!!
So yes we are left with 2nd and 3rd generation languages.
TALLYING UP THE PRO's and CON's:
--------------------------------
Assembly:
==++==++==++==
Advantages:
```````````
-control precisely what the processor does.
-use all of the features of the processor
-very fast
-very compact.
-in small programs it is also very predictable. Timings, for example, can be calculated very precisely and program flow is easily controlled. It is often used for small, real time applications.
- lowest and most elementary level of Programming language (In windows low is always higher ;D )
Disadvantages:
``````````````
-needs to have a good understanding of the hardware/software/api's being used.
-as programs become larger, assembly language get very cumbersome.
-maintenance of assembly language is notoriously difficult, especially if another programmer is brought in..
-Assembly langauge also has no support of an operating system
-no complex instructions. Storing and retrieving data is a simple task with high level languages; assembly needs the whole process to be programmed step by step. Mathmatical processes also have to be performed with binary addition and subtraction when using assembly which can get very complex.
-assembler is not portable (it is written for a particular instruction set)
-not for pussies :P
High Level Language:
+Understanding the different coding languages: Part #1
=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?
by cOrRupt G3n3t!x
So you want to be the best virus writer? But a VXer is only as good as the tools he uses and most importantly the language he programmes in and ofcourse the mind he was blessed with lol.
TYPES OF PROGRAMMING LANGUAGES:
-------------------------------
In a very broad term we have 5 types of programming languages:
1)First generation languages (abbreviated as 1GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*い*?*?*?*?*?*?*?*?
These are very primitive computer languages. It refers to 1's and 0's-Binary code-Which is the actual language that the computer understands (Machine code/language).The symbol 0 stands for the absence of Electric pulse and 1 for the presence of an electric pulse Programmers of the early 1950's, notably UNIVAC I and IBM 701, used machine language programs. Originally, no translator was used to compile or assemble the 1GL. The first-generation programming instructions were entered through the front panel switches of the computer system. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer.
Example code - Machine code:
?
10110000 01100001
?
Example code - Binary code:
?
B0 61
?
Example code - Binary code:
?
MOV AL, 61h ; Load AL with 97 decimal (61 hex)
?
2)Second generation languages (2GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
Next on the plate is 2GL languages also known as assembly languages. The code written in assembly languages are then converted to 1GL languages via a compiler. The programming language of assembly was a great step ahead that of 1GL languages as they now used symbolic names instead of numbers/binary code and evolved to include the use of macro instructions. This happened in the early-to-late 1950s. although assembly is not to different in its variations we have TASM, MASM,NASM and FASM syntaxes whixh are mainly just differents ways of moving variables etc i.e 'mov eax,[ecx]' in FASM and the equivalent in MASM would be 'mov eax,ecx'. So the variations are little to none.
?
;Example code - MASM32 Syntax:
mov ecx, 6 ; ecx=6
mov eax, 2; eax =2
add eax, ecx ;6+2
push eax
pop mt
cmp mt,8;8=8
jz oo ;jump if 0
ret ;return
oo:
invoke ExitProcess,0 ;exit
?
3)Third generation languages (3GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
In the 3GL of languages words and commands formed the syntax of the language rather than symbols and numbers. These were later dubbed known as "high level languages" and include C, C++, Java, VBS, JavaScript, BASIC and Delphi among many others.
?
//Example code - C# syntax:
while (true)
{
Process[] enumerateProcess = Process.GetProcesses();
foreach (Process process in enumerateProcess)
{
if (process.ProcessName.Equals("iexplorer.exe"))
{
Console.WriteLine("InternetExplorer IS ALIVE");
}
}
}
?
4)Fourth generation languages (4GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
The 4GL sees us coming closer to a human understandable language much like a sentence which holds more meaning than a command. these languages include, SQL, ColdFusion, FOCUS and MATLAB's GUIDE among others.Example code:
?
EXTRACT ALL CUSTOMERS WHERE "PREVIOUS PURCHASES" TOTAL MORE THAN $1000
?
5)Fifth generation languages (5GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
These languages are currently being used for neural networks. A nueral network is a form of artifical intelligence that attempts to imitate how the human mind works.It is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer.Examples are Prolog, OPS5, and Mercury.
Example code: right now imlementation is on the visual side of things such as drag and drop of hierarchy classes etc forming the basis.
SCRATCHING 'EM:
---------------
With the above in mind, we can now look at which are our best options. Well let me tell you 2GL and 3GL.
Why you may ask?
Well due to the sheer complexity of 1GL languages i.e manually calculating adresses, offsets, memory locations etc, make it an unlikely choice, and lets not start on the portability!
Next would be the 4GL language, and although it is possible to write viruses for/in it is not considered to be a great platform for virus writing. Viruses may write malicious code to 4GL languages however it is not possible to implement copy function etc in the language its is more an add on so learnong the syntax will increase your potential in virus writing but definitely not be benificail to learn by itself.
Lastly there is 5GL... Well find me a language that is truely 5GL and not some 4GL+EXTRA's and we can talk. But imagine a virus that can 'think' for itself :)!!
So yes we are left with 2nd and 3rd generation languages.
TALLYING UP THE PRO's and CON's:
--------------------------------
Assembly:
==++==++==++==
Advantages:
```````````
-control precisely what the processor does.
-use all of the features of the processor
-very fast
-very compact.
-in small programs it is also very predictable. Timings, for example, can be calculated very precisely and program flow is easily controlled. It is often used for small, real time applications.
- lowest and most elementary level of Programming language (In windows low is always higher ;D )
Disadvantages:
``````````````
-needs to have a good understanding of the hardware/software/api's being used.
-as programs become larger, assembly language get very cumbersome.
-maintenance of assembly language is notoriously difficult, especially if another programmer is brought in..
-Assembly langauge also has no support of an operating system
-no complex instructions. Storing and retrieving data is a simple task with high level languages; assembly needs the whole process to be programmed step by step. Mathmatical processes also have to be performed with binary addition and subtraction when using assembly which can get very complex.
-assembler is not portable (it is written for a particular instruction set)
-not for pussies :P
High Level Language:
++==Understanding the different coding languages: Part #1
=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?
by cOrRupt G3n3t!x
So you want to be the best virus writer? But a VXer is only as good as the tools he uses and most importantly the language he programmes in and ofcourse the mind he was blessed with lol.
TYPES OF PROGRAMMING LANGUAGES:
-------------------------------
In a very broad term we have 5 types of programming languages:
1)First generation languages (abbreviated as 1GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*い*?*?*?*?*?*?*?*?
These are very primitive computer languages. It refers to 1's and 0's-Binary code-Which is the actual language that the computer understands (Machine code/language).The symbol 0 stands for the absence of Electric pulse and 1 for the presence of an electric pulse Programmers of the early 1950's, notably UNIVAC I and IBM 701, used machine language programs. Originally, no translator was used to compile or assemble the 1GL. The first-generation programming instructions were entered through the front panel switches of the computer system. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer.
Example code - Machine code:
?
10110000 01100001
?
Example code - Binary code:
?
B0 61
?
Example code - Binary code:
?
MOV AL, 61h ; Load AL with 97 decimal (61 hex)
?
2)Second generation languages (2GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
Next on the plate is 2GL languages also known as assembly languages. The code written in assembly languages are then converted to 1GL languages via a compiler. The programming language of assembly was a great step ahead that of 1GL languages as they now used symbolic names instead of numbers/binary code and evolved to include the use of macro instructions. This happened in the early-to-late 1950s. although assembly is not to different in its variations we have TASM, MASM,NASM and FASM syntaxes whixh are mainly just differents ways of moving variables etc i.e 'mov eax,[ecx]' in FASM and the equivalent in MASM would be 'mov eax,ecx'. So the variations are little to none.
?
;Example code - MASM32 Syntax:
mov ecx, 6 ; ecx=6
mov eax, 2; eax =2
add eax, ecx ;6+2
push eax
pop mt
cmp mt,8;8=8
jz oo ;jump if 0
ret ;return
oo:
invoke ExitProcess,0 ;exit
?
3)Third generation languages (3GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
In the 3GL of languages words and commands formed the syntax of the language rather than symbols and numbers. These were later dubbed known as "high level languages" and include C, C++, Java, VBS, JavaScript, BASIC and Delphi among many others.
?
//Example code - C# syntax:
while (true)
{
Process[] enumerateProcess = Process.GetProcesses();
foreach (Process process in enumerateProcess)
{
if (process.ProcessName.Equals("iexplorer.exe"))
{
Console.WriteLine("InternetExplorer IS ALIVE");
}
}
}
?
4)Fourth generation languages (4GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
The 4GL sees us coming closer to a human understandable language much like a sentence which holds more meaning than a command. these languages include, SQL, ColdFusion, FOCUS and MATLAB's GUIDE among others.Example code:
?
EXTRACT ALL CUSTOMERS WHERE "PREVIOUS PURCHASES" TOTAL MORE THAN $1000
?
5)Fifth generation languages (5GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
These languages are currently being used for neural networks. A nueral network is a form of artifical intelligence that attempts to imitate how the human mind works.It is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer.Examples are Prolog, OPS5, and Mercury.
Example code: right now imlementation is on the visual side of things such as drag and drop of hierarchy classes etc forming the basis.
SCRATCHING 'EM:
---------------
With the above in mind, we can now look at which are our best options. Well let me tell you 2GL and 3GL.
Why you may ask?
Well due to the sheer complexity of 1GL languages i.e manually calculating adresses, offsets, memory locations etc, make it an unlikely choice, and lets not start on the portability!
Next would be the 4GL language, and although it is possible to write viruses for/in it is not considered to be a great platform for virus writing. Viruses may write malicious code to 4GL languages however it is not possible to implement copy function etc in the language its is more an add on so learnong the syntax will increase your potential in virus writing but definitely not be benificail to learn by itself.
Lastly there is 5GL... Well find me a language that is truely 5GL and not some 4GL+EXTRA's and we can talk. But imagine a virus that can 'think' for itself :)!!
So yes we are left with 2nd and 3rd generation languages.
TALLYING UP THE PRO's and CON's:
--------------------------------
Assembly:
==++==++==++==
Advantages:
```````````
-control precisely what the processor does.
-use all of the features of the processor
-very fast
-very compact.
-in small programs it is also very predictable. Timings, for example, can be calculated very precisely and program flow is easily controlled. It is often used for small, real time applications.
- lowest and most elementary level of Programming language (In windows low is always higher ;D )
Disadvantages:
``````````````
-needs to have a good understanding of the hardware/software/api's being used.
-as programs become larger, assembly language get very cumbersome.
-maintenance of assembly language is notoriously difficult, especially if another programmer is brought in..
-Assembly langauge also has no support of an operating system
-no complex instructions. Storing and retrieving data is a simple task with high level languages; assembly needs the whole process to be programmed step by step. Mathmatical processes also have to be performed with binary addition and subtraction when using assembly which can get very complex.
-assembler is not portable (it is written for a particular instruction set)
-not for pussies :P
High Level Language:
++==++==++==++==++==++==++
Advantages:
```````````
-less effort to wriUnderstanding the different coding languages: Part #1
=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?
by cOrRupt G3n3t!x
So you want to be the best virus writer? But a VXer is only as good as the tools he uses and most importantly the language he programmes in and ofcourse the mind he was blessed with lol.
TYPES OF PROGRAMMING LANGUAGES:
-------------------------------
In a very broad term we have 5 types of programming languages:
1)First generation languages (abbreviated as 1GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*い*?*?*?*?*?*?*?*?
These are very primitive computer languages. It refers to 1's and 0's-Binary code-Which is the actual language that the computer understands (Machine code/language).The symbol 0 stands for the absence of Electric pulse and 1 for the presence of an electric pulse Programmers of the early 1950's, notably UNIVAC I and IBM 701, used machine language programs. Originally, no translator was used to compile or assemble the 1GL. The first-generation programming instructions were entered through the front panel switches of the computer system. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer.
Example code - Machine code:
?
10110000 01100001
?
Example code - Binary code:
?
B0 61
?
Example code - Binary code:
?
MOV AL, 61h ; Load AL with 97 decimal (61 hex)
?
2)Second generation languages (2GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
Next on the plate is 2GL languages also known as assembly languages. The code written in assembly languages are then converted to 1GL languages via a compiler. The programming language of assembly was a great step ahead that of 1GL languages as they now used symbolic names instead of numbers/binary code and evolved to include the use of macro instructions. This happened in the early-to-late 1950s. although assembly is not to different in its variations we have TASM, MASM,NASM and FASM syntaxes whixh are mainly just differents ways of moving variables etc i.e 'mov eax,[ecx]' in FASM and the equivalent in MASM would be 'mov eax,ecx'. So the variations are little to none.
?
;Example code - MASM32 Syntax:
mov ecx, 6 ; ecx=6
mov eax, 2; eax =2
add eax, ecx ;6+2
push eax
pop mt
cmp mt,8;8=8
jz oo ;jump if 0
ret ;return
oo:
invoke ExitProcess,0 ;exit
?
3)Third generation languages (3GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
In the 3GL of languages words and commands formed the syntax of the language rather than symbols and numbers. These were later dubbed known as "high level languages" and include C, C++, Java, VBS, JavaScript, BASIC and Delphi among many others.
?
//Example code - C# syntax:
while (true)
{
Process[] enumerateProcess = Process.GetProcesses();
foreach (Process process in enumerateProcess)
{
if (process.ProcessName.Equals("iexplorer.exe"))
{
Console.WriteLine("InternetExplorer IS ALIVE");
}
}
}
?
4)Fourth generation languages (4GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
The 4GL sees us coming closer to a human understandable language much like a sentence which holds more meaning than a command. these languages include, SQL, ColdFusion, FOCUS and MATLAB's GUIDE among others.Example code:
?
EXTRACT ALL CUSTOMERS WHERE "PREVIOUS PURCHASES" TOTAL MORE THAN $1000
?
5)Fifth generation languages (5GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
These languages are currently being used for neural networks. A nueral network is a form of artifical intelligence that attempts to imitate how the human mind works.It is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer.Examples are Prolog, OPS5, and Mercury.
Example code: right now imlementation is on the visual side of things such as drag and drop of hierarchy classes etc forming the basis.
SCRATCHING 'EM:
---------------
With the above in mind, we can now look at which are our best options. Well let me tell you 2GL and 3GL.
Why you may ask?
Well due to the sheer complexity of 1GL languages i.e manually calculating adresses, offsets, memory locations etc, make it an unlikely choice, and lets not start on the portability!
Next would be the 4GL language, and although it is possible to write viruses for/in it is not considered to be a great platform for virus writing. Viruses may write malicious code to 4GL languages however it is not possible to implement copy function etc in the language its is more an add on so learnong the syntax will increase your potential in virus writing but definitely not be benificail to learn by itself.
Lastly there is 5GL... Well find me a language that is truely 5GL and not some 4GL+EXTRA's and we can talk. But imagine a virus that can 'think' for itself :)!!
So yes we are left with 2nd and 3rd generation languages.
TALLYING UP THE PRO's and CON's:
--------------------------------
Assembly:
==++==++==++==
Advantages:
```````````
-control precisely what the processor does.
-use all of the features of the processor
-very fast
-very compact.
-in small programs it is also very predictable. Timings, for example, can be calculated very precisely and program flow is easily controlled. It is often used for small, real time applications.
- lowest and most elementary level of Programming language (In windows low is always higher ;D )
Disadvantages:
``````````````
-needs to have a good understanding of the hardware/software/api's being used.
-as programs become larger, assembly language get very cumbersome.
-maintenance of assembly language is notoriously difficult, especially if another programmer is brought in..
-Assembly langauge also has no support of an operating system
-no complex instructions. Storing and retrieving data is a simple task with high level languages; assembly needs the whole process to be programmed step by step. Mathmatical processes also have to be performed with binary addition and subtraction when using assembly which can get very complex.
-assembler is not portable (it is written for a particular instruction set)
-not for pussies :P
High Level Language:
++==++==++==++==++==++==++
Advantages:了解不同的编码语言：＃1
= = = = = = = = = = = = = = =
腐败G3n3t！
所以，你想，是最好的病毒作家？但VXer是只有像他使用的工具和最重要的语言，他计划和ofcourse的心中，他是LOL祝福。
编程语言的种类：
-------------------------------
在一个非常宽泛的术语，我们有5种类型的编程语言：
1）第一代语言（缩写为1GL）
* * * * * * * * * * * * * * * * * * * * * * * * *い* * * * * * * * * * * * * * * *
这些都是非常原始的计算机语言。是指1的和0's的二进制代码，哪些是在实际语言的计算机理解（机器代码/语言）。“符号0代表没有电脉冲和1存在一个20世纪50年代初期的电脉冲编程特别是UNIVAC我和IBM 701，使用机器语言程序。本来，没有翻译，编译或组装1GL。第一代的编程指令输入计算机系统通过前面板开关。此外，便携性是显着降低 - 为了转移到另一台计算机，它需要完全改写，因为一台计算机的机器语言，可以从另一台计算机上显著不同的代码。
示例代码 - 机器码：
10110000 01100001
示例代码 - 二进制代码：
B0 61
示例代码 - 二进制代码：
MOV AL，61H;负载AL 97十进制（61进制）
2）第二代语言（2GL）
* * * * * * * * * * * * * * * * * * * * * * * * * *
上盘接下来是2GL又称汇编语言的语言。在汇编语言编写的代码，然后通过编译器转换成1GL语言。 1GL，因为他们现在使用的符号名称而不是数字/二进制代码，并发展到包括使用宏指令的语言，对大会的编程语言是一个伟大的先行一步。这发生在早期到20世纪50年代末。虽然大会及其变化不同，我们有TASM，MASM，NASM和FASM语法whixh主要只是differents变量等即移动方式MOV EAX，[ECX]“FASM，相当于在MASM将”MOV EAX ，ECX“。因此，变化是几乎没有。
示例代码 - MASM32语法：
6 MOV ECX，ECX = 6
2 MOV EAX，EAX = 2
ADD EAX，ECX; 6 2
PUSH EAX
弹出MT
CMP 8吨，8 = 8;
JZ OO;跳0
RET;返回
OO：
调用ExitProcess，0;退出
3）第三代语言（3GL）
* * * * * * * * * * * * * * * * * * * * * * * * * *
在3GL语言文字和命令形成的符号和数字，而不是语言的语法。这些后来被称为“高级语言”，其中包括C，C + +，JAVA，VBS，JAVASCRIPT，BASIC和德尔福在许多其他之中。
/ /示例代码 - C＃语法：
（真实）
{
[进程] enumerateProcess = Process.GetProcesses（）;
的foreach（enumerateProcess过程过程）
{
（process.ProcessName.Equals（“iexplorer.exe”））
{
（“的InternetExplorer还活着”）;
}
}
}
4）第四代语言（4GL）
* * * * * * * * * * * * * * * * * * * * * * * * * *
4GL看到我们越来越接近人类很像一个句子持有以上命令的意思是可以理解的语言。这些语言包括SQL，ColdFusion的，焦点和MATLAB的others.Example代码之间指南：
提取所有客户“以前的购买”总额超过1000
5）第五代语言（5GL）
* * * * * * * * * * * * * * * * * * * * * * * * * *
目前正在使用这些语言神经网络。一个nueral网络是人工智能试图模仿人的心灵works.It是一种编程语言，围绕解决使用给定的程序，而不是使用一个programmer.Examples书面算法，约束的问题如何形成的Prolog，OPS5和水星。
示例代码：现在imlementation对视觉方面的东西，如拖动和层次结构类下降等形成的基础。
抓挠“的EM：
---------------
鉴于上述，我们现在可以看看哪些是我们最好的选择。那么让我告诉你2GL和3GL。
为什么你会问？
不会忽略，由于1GL语言的复杂性，即手工计算偏移，内存位置等，使其一个不太可能的选择，并让无法启动的可移植性！
下一步将4GL语言，虽然它可能写/它不被认为是一个伟大的平台病毒编写的病毒。病毒可能会4GL语言编写的恶意代码，但它是不可能实现语言，它是多所以learnong语法会增加病毒编写您的潜力，但绝对不会benificail学习本身添加的复制功能等。
最后，还有5GL ...发现我一语，是真正5GL和一些4GL +额外的，我们可以谈。不过，想象一个可以为自己的“认为”病毒：）！！
所以，是我们剩下的第二代和第三代语言。
理货向上亲的和Con的：
--------------------------------
大会：
==++==++==++==
优点：
```````````
精确地控制处理器做什么。
使用所有的处理器的功能
速度非常快
非常紧凑。
在小程序，它也很容易预测。计时，例如，可以非常精确地计算和程序流很容易控制。它通常用于小型，实时应用。
- 最低和最基本的编程语言水平（低在窗口始终较高，D）
缺点：
``````````````
需要有一个良好的硬件/软件/ API“正在使用的认识。
当程序变得更大，汇编语言很繁琐。
汇编语言的维护是非常困难的，特别是如果另一个程序员带来英寸的。
- 大会langauge也没有操作系统的支持
没有复杂的指令。存储和检索数据与高级语言的一个简单的任务;大会需要的全过程，要一步一步的编程。 Mathmatical进程也有与二进制加法和减法时使用大会可以变得非常复杂。
汇编器是不可移植的（它是一个特定的指令集编写）
不为pussies：P
高层次的语言：
++==++==++==++==++==++==++
优点：
```````````
事半功倍编写复杂的程序
提供多种语言（也许还不错）
从各种语言的简单转换
对特定类型的计算机无关
- 更易于维护/可读
缺点：
``````````````
访问更多的低级别的功能都将丢失。
由于编译时间比汇编慢。
为等效的汇编语言程序相比，对象翻译生成的代码可能是低效
内存管理
它的意义ALL：
-----------------------
所以，当谈到选择一种语言怎么办我们知道高层次或assmebly？
那么它变得很明显，我水平高，最完整的，必须学习... ...但相同的是说，进行组装。所以，学会在我的opnion两个
第一个高层次的语言，然后大会...
```````````
-less effort to write complex programs
-multiple languages available(maybe also bad)
-simple conversions from the various languages
-independant on a particular type of computer
-more maintainable/readable
Disadvantages:
``````````````
-access to more low-level functionalities are lost.
-Slower than assembler due to compile time.
-The object code generated by a translator might be inefficient Compared to an equivalent assembly language program
-memory management
MAKING SENSE OF IT ALL:
-----------------------
So when it comes to choosing a language how do we know high level or assmebly?
Well it becomes apparent to me that high level is the most integral and must be learnt.... but the same is said for assembly. So in my opnion learn both
first a high level language and then assembly...
te complex programs
-multiple languages available(maybe also bad)
-simple conversions from the various languages
-independant on a particular type of computer
-more maintainable/readable
Disadvantages:
``````````````
-access to more low-level functionalities are lost.
-Slower than assembler due to compile time.
-The object code generated by a translator might be inefficient Compared to an equivalent assembly language program
-memory management
MAKING SENSE OF IT ALL:
-----------------------
So when it comes to choosing a language how do we know high level or assmebly?
Well it becomes apparent to me that high level is the most integral and must be learnt.... but the same is said for assembly. So in my opnion learn both
first a high level language and then assembly...
++==++==++==++==++==++
Advantages:
```````````
-less effort to write complex programs
-multiple languages available(maybe also bad)
-simple conversions from the various languages
-independant on a particular type of computer
-more maintainable/readable
Disadvantages:
``````````````
-access to more low-level functionalities are lost.
-Slower than assembler due to compile time.
-The object code generated by a translator might be inefficient Compared to an equivalent assembly language program
-memory management
MAKING SENSE OF IT ALL:
-----------------------
So when it comes to choosing a language how do we know high level or assmebly?
Well it becomes apparent to me that high level is the most integral and must be learnt.... but the same is said for assembly. So in my opnion learn both
first a high level language and then assembly...
+==++==++==++==++==++==++
Advantages:
```````````
-less effort to write complex programs
-multiple languages available(maybe also bad)
-simple conversions from the various languages
-independant on a particular type of computer
-more maintainable/readable
Disadvantages:
``````````````
-access to more low-level functionalities are lost.
-Slower than assembler due to compile time.
-The object code generated by a translator might be inefficient Compared to an equivalent assembly language program
-memory management
MAKING SENSE OF IT ALL:
-----------------------
So when it comes to choosing a language how do we know high level or assmebly?
Well it becomes apparent to me that high level is the most integral and must be learnt.... but the same is said for assembly. So in my opnion learn both
first a high level language and then assembly...
=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?
by cOrRupt G3n3t!x
So you want to be the best virus writer? But a VXer is only as good as the tools he uses and most importantly the language he programmes in and ofcourse the mind he was blessed with lol.
TYPES OF PROGRAMMING LANGUAGES:
-------------------------------
In a very broad term we have 5 types of programming languages:
1)First generation languages (abbreviated as 1GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*い*?*?*?*?*?*?*?*?
These are very primitive computer languages. It refers to 1's and 0's-Binary code-Which is the actual language that the computer understands (Machine code/language).The symbol 0 stands for the absence of Electric pulse and 1 for the presence of an electric pulse Programmers of the early 1950's, notably UNIVAC I and IBM 701, used machine language programs. Originally, no translator was used to compile or assemble the 1GL. The first-generation programming instructions were entered through the front panel switches of the computer system. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer.
Example code - Machine code:
?
10110000 01100001
?
Example code - Binary code:
?
B0 61
?
Example code - Binary code:
?
MOV AL, 61h ; Load AL with 97 decimal (61 hex)
?
2)Second generation languages (2GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
Next on the plate is 2GL languages also known as assembly languages. The code written in assembly languages are then converted to 1GL languages via a compiler. The programming language of assembly was a great step ahead that of 1GL languages as they now used symbolic names instead of numbers/binary code and evolved to include the use of macro instructions. This happened in the early-to-late 1950s. although assembly is not to different in its variations we have TASM, MASM,NASM and FASM syntaxes whixh are mainly just differents ways of moving variables etc i.e 'mov eax,[ecx]' in FASM and the equivalent in MASM would be 'mov eax,ecx'. So the variations are little to none.
?
;Example code - MASM32 Syntax:
mov ecx, 6 ; ecx=6
mov eax, 2; eax =2
add eax, ecx ;6+2
push eax
pop mt
cmp mt,8;8=8
jz oo ;jump if 0
ret ;return
oo:
invoke ExitProcess,0 ;exit
?
3)Third generation languages (3GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
In the 3GL of languages words and commands formed the syntax of the language rather than symbols and numbers. These were later dubbed known as "high level languages" and include C, C++, Java, VBS, JavaScript, BASIC and Delphi among many others.
?
//Example code - C# syntax:
while (true)
{
Process[] enumerateProcess = Process.GetProcesses();
foreach (Process process in enumerateProcess)
{
if (process.ProcessName.Equals("iexplorer.exe"))
{
Console.WriteLine("InternetExplorer IS ALIVE");
}
}
}
?
4)Fourth generation languages (4GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
The 4GL sees us coming closer to a human understandable language much like a sentence which holds more meaning than a command. these languages include, SQL, ColdFusion, FOCUS and MATLAB's GUIDE among others.Example code:
?
EXTRACT ALL CUSTOMERS WHERE "PREVIOUS PURCHASES" TOTAL MORE THAN $1000
?
5)Fifth generation languages (5GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
These languages are currently being used for neural networks. A nueral network is a form of artifical intelligence that attempts to imitate how the human mind works.It is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer.Examples are Prolog, OPS5, and Mercury.
Example code: right now imlementation is on the visual side of things such as drag and drop of hierarchy classes etc forming the basis.
SCRATCHING 'EM:
---------------
With the above in mind, we can now look at which are our best options. Well let me tell you 2GL and 3GL.
Why you may ask?
Well due to the sheer complexity of 1GL languages i.e manually calculating adresses, offsets, memory locations etc, make it an unlikely choice, and lets not start on the portability!
Next would be the 4GL language, and although it is possible to write viruses for/in it is not considered to be a great platform for virus writing. Viruses may write malicious code to 4GL languages however it is not possible to implement copy function etc in the language its is more an add on so learnong the syntax will increase your potential in virus writing but definitely not be benificail to learn by itself.
Lastly there is 5GL... Well find me a language that is truely 5GL and not some 4GL+EXTRA's and we can talk. But imagine a virus that can 'think' for itself :)!!
So yes we are left with 2nd and 3rd generation languages.
TALLYING UP THE PRO's and CON's:
--------------------------------
Assembly:
==++==++==++==
Advantages:
```````````
-control precisely what the processor does.
-use all of the features of the processor
-very fast
-very compact.
-in small programs it is also very predictable. Timings, for example, can be calculated very precisely and program flow is easily controlled. It is often used for small, real time applications.
- lowest and most elementary level of Programming language (In windows low is always higher ;D )
Disadvantages:
``````````````
-needs to have a good understanding of the hardware/software/api's being used.
-as programs become larger, assembly language get very cumbersome.
-maintenance of assembly language is notoriously difficult, especially if another programmer is brought in..
-Assembly langauge also has no support of an operating system
-no complex instructions. Storing and retrieving data is a simple task with high level languages; assembly needs the whole process to be programmed step by step. Mathmatical processes also have to be performed with binary addition and subtraction when using assembly which can get very complex.
-assembler is not portable (it is written for a particular instruction set)
-not for pussies :P
High Level Language:
+Understanding the different coding languages: Part #1
=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?
by cOrRupt G3n3t!x
So you want to be the best virus writer? But a VXer is only as good as the tools he uses and most importantly the language he programmes in and ofcourse the mind he was blessed with lol.
TYPES OF PROGRAMMING LANGUAGES:
-------------------------------
In a very broad term we have 5 types of programming languages:
1)First generation languages (abbreviated as 1GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*い*?*?*?*?*?*?*?*?
These are very primitive computer languages. It refers to 1's and 0's-Binary code-Which is the actual language that the computer understands (Machine code/language).The symbol 0 stands for the absence of Electric pulse and 1 for the presence of an electric pulse Programmers of the early 1950's, notably UNIVAC I and IBM 701, used machine language programs. Originally, no translator was used to compile or assemble the 1GL. The first-generation programming instructions were entered through the front panel switches of the computer system. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer.
Example code - Machine code:
?
10110000 01100001
?
Example code - Binary code:
?
B0 61
?
Example code - Binary code:
?
MOV AL, 61h ; Load AL with 97 decimal (61 hex)
?
2)Second generation languages (2GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
Next on the plate is 2GL languages also known as assembly languages. The code written in assembly languages are then converted to 1GL languages via a compiler. The programming language of assembly was a great step ahead that of 1GL languages as they now used symbolic names instead of numbers/binary code and evolved to include the use of macro instructions. This happened in the early-to-late 1950s. although assembly is not to different in its variations we have TASM, MASM,NASM and FASM syntaxes whixh are mainly just differents ways of moving variables etc i.e 'mov eax,[ecx]' in FASM and the equivalent in MASM would be 'mov eax,ecx'. So the variations are little to none.
?
;Example code - MASM32 Syntax:
mov ecx, 6 ; ecx=6
mov eax, 2; eax =2
add eax, ecx ;6+2
push eax
pop mt
cmp mt,8;8=8
jz oo ;jump if 0
ret ;return
oo:
invoke ExitProcess,0 ;exit
?
3)Third generation languages (3GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
In the 3GL of languages words and commands formed the syntax of the language rather than symbols and numbers. These were later dubbed known as "high level languages" and include C, C++, Java, VBS, JavaScript, BASIC and Delphi among many others.
?
//Example code - C# syntax:
while (true)
{
Process[] enumerateProcess = Process.GetProcesses();
foreach (Process process in enumerateProcess)
{
if (process.ProcessName.Equals("iexplorer.exe"))
{
Console.WriteLine("InternetExplorer IS ALIVE");
}
}
}
?
4)Fourth generation languages (4GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
The 4GL sees us coming closer to a human understandable language much like a sentence which holds more meaning than a command. these languages include, SQL, ColdFusion, FOCUS and MATLAB's GUIDE among others.Example code:
?
EXTRACT ALL CUSTOMERS WHERE "PREVIOUS PURCHASES" TOTAL MORE THAN $1000
?
5)Fifth generation languages (5GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
These languages are currently being used for neural networks. A nueral network is a form of artifical intelligence that attempts to imitate how the human mind works.It is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer.Examples are Prolog, OPS5, and Mercury.
Example code: right now imlementation is on the visual side of things such as drag and drop of hierarchy classes etc forming the basis.
SCRATCHING 'EM:
---------------
With the above in mind, we can now look at which are our best options. Well let me tell you 2GL and 3GL.
Why you may ask?
Well due to the sheer complexity of 1GL languages i.e manually calculating adresses, offsets, memory locations etc, make it an unlikely choice, and lets not start on the portability!
Next would be the 4GL language, and although it is possible to write viruses for/in it is not considered to be a great platform for virus writing. Viruses may write malicious code to 4GL languages however it is not possible to implement copy function etc in the language its is more an add on so learnong the syntax will increase your potential in virus writing but definitely not be benificail to learn by itself.
Lastly there is 5GL... Well find me a language that is truely 5GL and not some 4GL+EXTRA's and we can talk. But imagine a virus that can 'think' for itself :)!!
So yes we are left with 2nd and 3rd generation languages.
TALLYING UP THE PRO's and CON's:
--------------------------------
Assembly:
==++==++==++==
Advantages:
```````````
-control precisely what the processor does.
-use all of the features of the processor
-very fast
-very compact.
-in small programs it is also very predictable. Timings, for example, can be calculated very precisely and program flow is easily controlled. It is often used for small, real time applications.
- lowest and most elementary level of Programming language (In windows low is always higher ;D )
Disadvantages:
``````````````
-needs to have a good understanding of the hardware/software/api's being used.
-as programs become larger, assembly language get very cumbersome.
-maintenance of assembly language is notoriously difficult, especially if another programmer is brought in..
-Assembly langauge also has no support of an operating system
-no complex instructions. Storing and retrieving data is a simple task with high level languages; assembly needs the whole process to be programmed step by step. Mathmatical processes also have to be performed with binary addition and subtraction when using assembly which can get very complex.
-assembler is not portable (it is written for a particular instruction set)
-not for pussies :P
High Level Language:
++==Understanding the different coding languages: Part #1
=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?
by cOrRupt G3n3t!x
So you want to be the best virus writer? But a VXer is only as good as the tools he uses and most importantly the language he programmes in and ofcourse the mind he was blessed with lol.
TYPES OF PROGRAMMING LANGUAGES:
-------------------------------
In a very broad term we have 5 types of programming languages:
1)First generation languages (abbreviated as 1GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*い*?*?*?*?*?*?*?*?
These are very primitive computer languages. It refers to 1's and 0's-Binary code-Which is the actual language that the computer understands (Machine code/language).The symbol 0 stands for the absence of Electric pulse and 1 for the presence of an electric pulse Programmers of the early 1950's, notably UNIVAC I and IBM 701, used machine language programs. Originally, no translator was used to compile or assemble the 1GL. The first-generation programming instructions were entered through the front panel switches of the computer system. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer.
Example code - Machine code:
?
10110000 01100001
?
Example code - Binary code:
?
B0 61
?
Example code - Binary code:
?
MOV AL, 61h ; Load AL with 97 decimal (61 hex)
?
2)Second generation languages (2GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
Next on the plate is 2GL languages also known as assembly languages. The code written in assembly languages are then converted to 1GL languages via a compiler. The programming language of assembly was a great step ahead that of 1GL languages as they now used symbolic names instead of numbers/binary code and evolved to include the use of macro instructions. This happened in the early-to-late 1950s. although assembly is not to different in its variations we have TASM, MASM,NASM and FASM syntaxes whixh are mainly just differents ways of moving variables etc i.e 'mov eax,[ecx]' in FASM and the equivalent in MASM would be 'mov eax,ecx'. So the variations are little to none.
?
;Example code - MASM32 Syntax:
mov ecx, 6 ; ecx=6
mov eax, 2; eax =2
add eax, ecx ;6+2
push eax
pop mt
cmp mt,8;8=8
jz oo ;jump if 0
ret ;return
oo:
invoke ExitProcess,0 ;exit
?
3)Third generation languages (3GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
In the 3GL of languages words and commands formed the syntax of the language rather than symbols and numbers. These were later dubbed known as "high level languages" and include C, C++, Java, VBS, JavaScript, BASIC and Delphi among many others.
?
//Example code - C# syntax:
while (true)
{
Process[] enumerateProcess = Process.GetProcesses();
foreach (Process process in enumerateProcess)
{
if (process.ProcessName.Equals("iexplorer.exe"))
{
Console.WriteLine("InternetExplorer IS ALIVE");
}
}
}
?
4)Fourth generation languages (4GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
The 4GL sees us coming closer to a human understandable language much like a sentence which holds more meaning than a command. these languages include, SQL, ColdFusion, FOCUS and MATLAB's GUIDE among others.Example code:
?
EXTRACT ALL CUSTOMERS WHERE "PREVIOUS PURCHASES" TOTAL MORE THAN $1000
?
5)Fifth generation languages (5GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
These languages are currently being used for neural networks. A nueral network is a form of artifical intelligence that attempts to imitate how the human mind works.It is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer.Examples are Prolog, OPS5, and Mercury.
Example code: right now imlementation is on the visual side of things such as drag and drop of hierarchy classes etc forming the basis.
SCRATCHING 'EM:
---------------
With the above in mind, we can now look at which are our best options. Well let me tell you 2GL and 3GL.
Why you may ask?
Well due to the sheer complexity of 1GL languages i.e manually calculating adresses, offsets, memory locations etc, make it an unlikely choice, and lets not start on the portability!
Next would be the 4GL language, and although it is possible to write viruses for/in it is not considered to be a great platform for virus writing. Viruses may write malicious code to 4GL languages however it is not possible to implement copy function etc in the language its is more an add on so learnong the syntax will increase your potential in virus writing but definitely not be benificail to learn by itself.
Lastly there is 5GL... Well find me a language that is truely 5GL and not some 4GL+EXTRA's and we can talk. But imagine a virus that can 'think' for itself :)!!
So yes we are left with 2nd and 3rd generation languages.
TALLYING UP THE PRO's and CON's:
--------------------------------
Assembly:
==++==++==++==
Advantages:
```````````
-control precisely what the processor does.
-use all of the features of the processor
-very fast
-very compact.
-in small programs it is also very predictable. Timings, for example, can be calculated very precisely and program flow is easily controlled. It is often used for small, real time applications.
- lowest and most elementary level of Programming language (In windows low is always higher ;D )
Disadvantages:
``````````````
-needs to have a good understanding of the hardware/software/api's being used.
-as programs become larger, assembly language get very cumbersome.
-maintenance of assembly language is notoriously difficult, especially if another programmer is brought in..
-Assembly langauge also has no support of an operating system
-no complex instructions. Storing and retrieving data is a simple task with high level languages; assembly needs the whole process to be programmed step by step. Mathmatical processes also have to be performed with binary addition and subtraction when using assembly which can get very complex.
-assembler is not portable (it is written for a particular instruction set)
-not for pussies :P
High Level Language:
++==++==++==++==++==++==++
Advantages:
```````````
-less effort to wriUnderstanding the different coding languages: Part #1
=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?=?
by cOrRupt G3n3t!x
So you want to be the best virus writer? But a VXer is only as good as the tools he uses and most importantly the language he programmes in and ofcourse the mind he was blessed with lol.
TYPES OF PROGRAMMING LANGUAGES:
-------------------------------
In a very broad term we have 5 types of programming languages:
1)First generation languages (abbreviated as 1GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*い*?*?*?*?*?*?*?*?
These are very primitive computer languages. It refers to 1's and 0's-Binary code-Which is the actual language that the computer understands (Machine code/language).The symbol 0 stands for the absence of Electric pulse and 1 for the presence of an electric pulse Programmers of the early 1950's, notably UNIVAC I and IBM 701, used machine language programs. Originally, no translator was used to compile or assemble the 1GL. The first-generation programming instructions were entered through the front panel switches of the computer system. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer.
Example code - Machine code:
?
10110000 01100001
?
Example code - Binary code:
?
B0 61
?
Example code - Binary code:
?
MOV AL, 61h ; Load AL with 97 decimal (61 hex)
?
2)Second generation languages (2GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
Next on the plate is 2GL languages also known as assembly languages. The code written in assembly languages are then converted to 1GL languages via a compiler. The programming language of assembly was a great step ahead that of 1GL languages as they now used symbolic names instead of numbers/binary code and evolved to include the use of macro instructions. This happened in the early-to-late 1950s. although assembly is not to different in its variations we have TASM, MASM,NASM and FASM syntaxes whixh are mainly just differents ways of moving variables etc i.e 'mov eax,[ecx]' in FASM and the equivalent in MASM would be 'mov eax,ecx'. So the variations are little to none.
?
;Example code - MASM32 Syntax:
mov ecx, 6 ; ecx=6
mov eax, 2; eax =2
add eax, ecx ;6+2
push eax
pop mt
cmp mt,8;8=8
jz oo ;jump if 0
ret ;return
oo:
invoke ExitProcess,0 ;exit
?
3)Third generation languages (3GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
In the 3GL of languages words and commands formed the syntax of the language rather than symbols and numbers. These were later dubbed known as "high level languages" and include C, C++, Java, VBS, JavaScript, BASIC and Delphi among many others.
?
//Example code - C# syntax:
while (true)
{
Process[] enumerateProcess = Process.GetProcesses();
foreach (Process process in enumerateProcess)
{
if (process.ProcessName.Equals("iexplorer.exe"))
{
Console.WriteLine("InternetExplorer IS ALIVE");
}
}
}
?
4)Fourth generation languages (4GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
The 4GL sees us coming closer to a human understandable language much like a sentence which holds more meaning than a command. these languages include, SQL, ColdFusion, FOCUS and MATLAB's GUIDE among others.Example code:
?
EXTRACT ALL CUSTOMERS WHERE "PREVIOUS PURCHASES" TOTAL MORE THAN $1000
?
5)Fifth generation languages (5GL)
*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?
These languages are currently being used for neural networks. A nueral network is a form of artifical intelligence that attempts to imitate how the human mind works.It is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer.Examples are Prolog, OPS5, and Mercury.
Example code: right now imlementation is on the visual side of things such as drag and drop of hierarchy classes etc forming the basis.
SCRATCHING 'EM:
---------------
With the above in mind, we can now look at which are our best options. Well let me tell you 2GL and 3GL.
Why you may ask?
Well due to the sheer complexity of 1GL languages i.e manually calculating adresses, offsets, memory locations etc, make it an unlikely choice, and lets not start on the portability!
Next would be the 4GL language, and although it is possible to write viruses for/in it is not considered to be a great platform for virus writing. Viruses may write malicious code to 4GL languages however it is not possible to implement copy function etc in the language its is more an add on so learnong the syntax will increase your potential in virus writing but definitely not be benificail to learn by itself.
Lastly there is 5GL... Well find me a language that is truely 5GL and not some 4GL+EXTRA's and we can talk. But imagine a virus that can 'think' for itself :)!!
So yes we are left with 2nd and 3rd generation languages.
TALLYING UP THE PRO's and CON's:
--------------------------------
Assembly:
==++==++==++==
Advantages:
```````````
-control precisely what the processor does.
-use all of the features of the processor
-very fast
-very compact.
-in small programs it is also very predictable. Timings, for example, can be calculated very precisely and program flow is easily controlled. It is often used for small, real time applications.
- lowest and most elementary level of Programming language (In windows low is always higher ;D )
Disadvantages:
``````````````
-needs to have a good understanding of the hardware/software/api's being used.
-as programs become larger, assembly language get very cumbersome.
-maintenance of assembly language is notoriously difficult, especially if another programmer is brought in..
-Assembly langauge also has no support of an operating system
-no complex instructions. Storing and retrieving data is a simple task with high level languages; assembly needs the whole process to be programmed step by step. Mathmatical processes also have to be performed with binary addition and subtraction when using assembly which can get very complex.
-assembler is not portable (it is written for a particular instruction set)
-not for pussies :P
High Level Language:
++==++==++==++==++==++==++
Advantages:了解不同的编码语言：＃1
= = = = = = = = = = = = = = =
腐败G3n3t！
所以，你想，是最好的病毒作家？但VXer是只有像他使用的工具和最重要的语言，他计划和ofcourse的心中，他是LOL祝福。
编程语言的种类：
-------------------------------
在一个非常宽泛的术语，我们有5种类型的编程语言：
1）第一代语言（缩写为1GL）
* * * * * * * * * * * * * * * * * * * * * * * * *い* * * * * * * * * * * * * * * *
这些都是非常原始的计算机语言。是指1的和0's的二进制代码，哪些是在实际语言的计算机理解（机器代码/语言）。“符号0代表没有电脉冲和1存在一个20世纪50年代初期的电脉冲编程特别是UNIVAC我和IBM 701，使用机器语言程序。本来，没有翻译，编译或组装1GL。第一代的编程指令输入计算机系统通过前面板开关。此外，便携性是显着降低 - 为了转移到另一台计算机，它需要完全改写，因为一台计算机的机器语言，可以从另一台计算机上显著不同的代码。
示例代码 - 机器码：
10110000 01100001
示例代码 - 二进制代码：
B0 61
示例代码 - 二进制代码：
MOV AL，61H;负载AL 97十进制（61进制）
2）第二代语言（2GL）
* * * * * * * * * * * * * * * * * * * * * * * * * *
上盘接下来是2GL又称汇编语言的语言。在汇编语言编写的代码，然后通过编译器转换成1GL语言。 1GL，因为他们现在使用的符号名称而不是数字/二进制代码，并发展到包括使用宏指令的语言，对大会的编程语言是一个伟大的先行一步。这发生在早期到20世纪50年代末。虽然大会及其变化不同，我们有TASM，MASM，NASM和FASM语法whixh主要只是differents变量等即移动方式MOV EAX，[ECX]“FASM，相当于在MASM将”MOV EAX ，ECX“。因此，变化是几乎没有。
示例代码 - MASM32语法：
6 MOV ECX，ECX = 6
2 MOV EAX，EAX = 2
ADD EAX，ECX; 6 2
PUSH EAX
弹出MT
CMP 8吨，8 = 8;
JZ OO;跳0
RET;返回
OO：
调用ExitProcess，0;退出
3）第三代语言（3GL）
* * * * * * * * * * * * * * * * * * * * * * * * * *
在3GL语言文字和命令形成的符号和数字，而不是语言的语法。这些后来被称为“高级语言”，其中包括C，C + +，JAVA，VBS，JAVASCRIPT，BASIC和德尔福在许多其他之中。
/ /示例代码 - C＃语法：
（真实）
{
[进程] enumerateProcess = Process.GetProcesses（）;
的foreach（enumerateProcess过程过程）
{
（process.ProcessName.Equals（“iexplorer.exe”））
{
（“的InternetExplorer还活着”）;
}
}
}
4）第四代语言（4GL）
* * * * * * * * * * * * * * * * * * * * * * * * * *
4GL看到我们越来越接近人类很像一个句子持有以上命令的意思是可以理解的语言。这些语言包括SQL，ColdFusion的，焦点和MATLAB的others.Example代码之间指南：
提取所有客户“以前的购买”总额超过1000
5）第五代语言（5GL）
* * * * * * * * * * * * * * * * * * * * * * * * * *
目前正在使用这些语言神经网络。一个nueral网络是人工智能试图模仿人的心灵works.It是一种编程语言，围绕解决使用给定的程序，而不是使用一个programmer.Examples书面算法，约束的问题如何形成的Prolog，OPS5和水星。
示例代码：现在imlementation对视觉方面的东西，如拖动和层次结构类下降等形成的基础。
抓挠“的EM：
---------------
鉴于上述，我们现在可以看看哪些是我们最好的选择。那么让我告诉你2GL和3GL。
为什么你会问？
不会忽略，由于1GL语言的复杂性，即手工计算偏移，内存位置等，使其一个不太可能的选择，并让无法启动的可移植性！
下一步将4GL语言，虽然它可能写/它不被认为是一个伟大的平台病毒编写的病毒。病毒可能会4GL语言编写的恶意代码，但它是不可能实现语言，它是多所以learnong语法会增加病毒编写您的潜力，但绝对不会benificail学习本身添加的复制功能等。
最后，还有5GL ...发现我一语，是真正5GL和一些4GL +额外的，我们可以谈。不过，想象一个可以为自己的“认为”病毒：）！！
所以，是我们剩下的第二代和第三代语言。
理货向上亲的和Con的：
--------------------------------
大会：
==++==++==++==
优点：
```````````
精确地控制处理器做什么。
使用所有的处理器的功能
速度非常快
非常紧凑。
在小程序，它也很容易预测。计时，例如，可以非常精确地计算和程序流很容易控制。它通常用于小型，实时应用。
- 最低和最基本的编程语言水平（低在窗口始终较高，D）
缺点：
``````````````
需要有一个良好的硬件/软件/ API“正在使用的认识。
当程序变得更大，汇编语言很繁琐。
汇编语言的维护是非常困难的，特别是如果另一个程序员带来英寸的。
- 大会langauge也没有操作系统的支持
没有复杂的指令。存储和检索数据与高级语言的一个简单的任务;大会需要的全过程，要一步一步的编程。 Mathmatical进程也有与二进制加法和减法时使用大会可以变得非常复杂。
汇编器是不可移植的（它是一个特定的指令集编写）
不为pussies：P
高层次的语言：
++==++==++==++==++==++==++
优点：
```````````
事半功倍编写复杂的程序
提供多种语言（也许还不错）
从各种语言的简单转换
对特定类型的计算机无关
- 更易于维护/可读
缺点：
``````````````
访问更多的低级别的功能都将丢失。
由于编译时间比汇编慢。
为等效的汇编语言程序相比，对象翻译生成的代码可能是低效
内存管理
它的意义ALL：
-----------------------
所以，当谈到选择一种语言怎么办我们知道高层次或assmebly？
那么它变得很明显，我水平高，最完整的，必须学习... ...但相同的是说，进行组装。所以，学会在我的opnion两个
第一个高层次的语言，然后大会...
```````````
-less effort to write complex programs
-multiple languages available(maybe also bad)
-simple conversions from the various languages
-independant on a particular type of computer
-more maintainable/readable
Disadvantages:
``````````````
-access to more low-level functionalities are lost.
-Slower than assembler due to compile time.
-The object code generated by a translator might be inefficient Compared to an equivalent assembly language program
-memory management
MAKING SENSE OF IT ALL:
-----------------------
So when it comes to choosing a language how do we know high level or assmebly?
Well it becomes apparent to me that high level is the most integral and must be learnt.... but the same is said for assembly. So in my opnion learn both
first a high level language and then assembly...
te complex programs
-multiple languages available(maybe also bad)
-simple conversions from the various languages
-independant on a particular type of computer
-more maintainable/readable
Disadvantages:
``````````````
-access to more low-level functionalities are lost.
-Slower than assembler due to compile time.
-The object code generated by a translator might be inefficient Compared to an equivalent assembly language program
-memory management
MAKING SENSE OF IT ALL:
-----------------------
So when it comes to choosing a language how do we know high level or assmebly?
Well it becomes apparent to me that high level is the most integral and must be learnt.... but the same is said for assembly. So in my opnion learn both
first a high level language and then assembly...
++==++==++==++==++==++
Advantages:
```````````
-less effort to write complex programs
-multiple languages available(maybe also bad)
-simple conversions from the various languages
-independant on a particular type of computer
-more maintainable/readable
Disadvantages:
``````````````
-access to more low-level functionalities are lost.
-Slower than assembler due to compile time.
-The object code generated by a translator might be inefficient Compared to an equivalent assembly language program
-memory management
MAKING SENSE OF IT ALL:
-----------------------
So when it comes to choosing a language how do we know high level or assmebly?
Well it becomes apparent to me that high level is the most integral and must be learnt.... but the same is said for assembly. So in my opnion learn both
first a high level language and then assembly...
+==++==++==++==++==++==++
Advantages:
```````````
-less effort to write complex programs
-multiple languages available(maybe also bad)
-simple conversions from the various languages
-independant on a particular type of computer
-more maintainable/readable
Disadvantages:
``````````````
-access to more low-level functionalities are lost.
-Slower than assembler due to compile time.
-The object code generated by a translator might be inefficient Compared to an equivalent assembly language program
-memory management
MAKING SENSE OF IT ALL:
-----------------------
So when it comes to choosing a language how do we know high level or assmebly?
Well it becomes apparent to me that high level is the most integral and must be learnt.... but the same is said for assembly. So in my opnion learn both
first a high level language and then assembly...