Amazon

Friday, June 24, 2016

C language Programming: Simple, Short, and Straightforward Way of Learning C Programming

C language Programming: Simple, Short, and Straightforward Way of Learning C Programming


Copyright 2016 - KDP Edition



Sherwyn Allibang




Edition License Notes
This book is authorized for your own personal use. This book may not be re-sold or offered away to other individuals. Much thanks to you for regarding the diligent work of the author.

Introduction
This book is for absolute beginners with or without prior knowledge in programming, as this book uses Simple words, Short sentences, and Straightforward paragraphs. The triple S way of learning C language programming. The topics covered in this book includes brief introduction to C language, variables, data types, control structures, functions, pointers, and input and output stream to external files. This book starts its discussion from short history to installation of the needed software resource and a step by step screen shots of how to write C language code, compile and execute C programs. It presents graphical representation of algorithms for simpler learning. This book is packed with working and running C program samples and after reading this book, the reader would be able to develop and create C language programs based particularly from problems given in computer science courses, hence, adopting to other programming language will be a lot easier. This book is your first step in your programming career.

TO GOD BE ALL THE GLORY!

The resources used in this book are:
> Personal Computer running Windows 7 Operating System     
> Dev-C++ available at http://bloodshed.net
Other Windows OS versions can also be used as long as it supports the above mentioned software. Also, you may ought to use other C compilers or IDE.


NOTE: All links provided in this book are updated occasionally. If a link becomes unavailable, email me at zherwyndbest@facebook.com


This chapter presents a brief overview of C language. It presents the things needed in starting C language programming.

Short history of C Language

C is a general-purpose high level language that was originally developed by Dennis Ritchie for the Unix operating system. It was first implemented on the Digital Equipment Corporation PDP-11 computer in 1972. The Unix operating system and virtually all Unix applications are written in the C language. C has now become a widely used professional language for various reasons:
1. Easy to learn.
2. Structured language.
3. Produces efficient programs.
4. It can handle low-level activities.
5. It can be compiled on a variety of computers.
6. It has a low-level language capability with the convenience of high-level programming.

C language was invented to write an operating system called UNIX. C is a successor of B language which was introduced around 1970. The language was formalized in 1988 by the American National Standard Institute (ANSI). By 1973 UNIX OS almost totally written in C. Today C is the most widely used System Programming Language. Most of the state of the art software have been implemented using C language.

Reasons to use C Language

To start with, I highly recommend C language for any beginning programmers to start their programming career because most of the high-level and other popular programming languages today is based from C language. Once you've learned the concepts behind programming language with C, adopting or migrating to other language will be easy as most of the things needed are pretty similar.

C was initially used for system development work, in particular the programs that make-up the operating system. C was adopted as a system development language because it produces code that runs nearly as fast as code written in assembly language. Some examples of the use of C might be:
1. Operating Systems
2. Language Compilers
3. Assemblers
4. Text Editors
4. Print Spoolers
5. Network Drivers
6. Modern Programs
7. Data Bases
8. Language Interpreters
9. Utilities
10. C Program File

Beginning to Program in C Language

All the C programs are written into text files with extension ".c" for example "hello.c", where ".c" is extension file name. These text files are called source files. The source files contains the C source codes and will later be transformed into a running executable file. The program development cycle of C language are:
1. Write the source codes into a text editor (ex: notepad) to create the source file.
2. Compile the source file to create the object file.
3. The object file is link into an executable (ex: .exe for windows) file.
4. Run the program and see the result.

Based from the program development cycle of C, notice that there are several things needed which includes a text editor, a compiler, and a linker. The good news is that, there is a software that comprises the three. It is called Dev-C++ which is available at http://bloodshed.net and for the download direct link at http://bloodshed-dev-c.en.softonic.com/download.
Dev-C++ is a C source code editor, a compiler, and a linker. All the things needed in creating a C program.
Note: You may ought to use other C compilers.

Installing the Dev-C++

Download the installer at the link provided above and install. Figure 1.1 presents the first screen upon running the installer.


Definition of programming terms

The following terms are defined conceptually and operationally in order to have a common understanding of the terms used in this book.
Argument. Arguments are actual value being pass to a function.
Bug. A bug is a general term used to describe any unexpected problem with the program during execution or when the programming is already running.
Block. A block is composed of two or more C statements. Also called compound statements. A block is enclosed with a pair of { } braces.
CamelCase. CamelCase is the naming convention for compound word which uses capital letters to delimit the word parts. For example, "studName", "studAge", and "intNum".
Clause. A section in the statement.
Code. It is the term used for statements written that make up a C program.
Condition. A statement that evaluates to either true (non zero) or false (zero).
Data Type. It the type of data being stored to a storage location like variable.
Debug. This refers to the process of examining and removing errors from a program's source code.
Expression. It is a statement that result to a numeric value.
Function. Function perform a specific task.
Label. Label is used a give details to a certain line of code in C language, hence this labels are ignored by the compiler, thus it does not affect the output of the program. Usually used for internal documentation.
Null. In computer programming, null is the term used for an uninitialized, undefined, empty, or meaningless value.
Parameter. Parameters are argument declaration of a function.
Statement. A statement is a complete direction instructing the computer to carry out some task. In C, statements are usually written one per line, although some statements span multiple lines. This term can be interchangeably use with code.
Syntax. Syntax is the grammar, structure, or order of the elements in a C language or any other programming language statement. (Semantics is the meaning of these elements.)
Variable. Variables are storage location for data in C programs.

The components of a C program

Lets discuss the components of a C programs through a sample program. This program prints the word "Hello World!" into the screen.  

Code listings of figure 2.1
#include"stdio.h"
main()
  {
  /*The line below prints a string*/
  printf("Hello World!");
  getch();
  }

Line 1. #include"stdio.h"
This line includes a C library for the use of the program. The inclusion of library in C program usually comes first.

Syntax #include directive:
#include"<lib-name>"

The <lib-name> in the syntax should be replaced with the library name. The other term for library is "include file" because literally, a library is a separate disk file that contains information needed by the program or the compiler.
The #include directive instructs the C compiler to add the contents of library or include file (sometimes called "Header files") into the program during compilation. The library files usually comes with the compiler, hence in Dev-C++, several libraries comes together with its default installation. These library files should have a ".h" file extension.
In line 1, the library included is the "stdio.h" which stands for standard input/output. This library is used in dealing with programs that accepts input and provides output, hence this is the most used library. Other libraries are discussed in the succeeding chapters of this book.

Line 2. main()
This line defines the main body of the program. The only component that is required in every C program is the main() function. In its simplest form, the main() function consists of the name main followed by a pair of empty parentheses ( ) and a pair of braces { } presented in lines 3 and 7. Within the braces are statements that make up the main body of the program. Under normal circumstances, program execution starts at the first statement in the main() function and terminates at the last statement in main().

Lines 3 and 7. { }
The curly braces { } are used to enclose the program lines that make up every C function including the main() function. A group of one or more statements enclosed within braces is called a block. Line 3 signifies the start of the content of the main function and line 7 signifies its end.

Line 4. /*The line below prints a string*/
The /*   */ (slash asterisk asterisk slash), are called comments. Anything enclose within the /* and */ becomes a comment. Comments are text details usually used by programmers to reference a line code statement in the source file. The comments are ignored by the compiler, hence does not affect the output of the program. The program will execute and run properly with or without comments. In line 4, the comments are used to give a reference or details that the next line will print a string on-screen.

Syntax for single-line comment:
/* <string-comment> */

The <string-comment> in the syntax should be replaced with a text entries that represents the comment of the programmer in the code. The comment can be on a single line or multi-line. Line 4 is an example of single line comment. Other compilers allows // as single line comment, which anything that follows // in the same line is considered comment. DevC++ allows the use of // as a single line comment.

Syntax for multi-line comment:
/* <string-comment-string-comment
-string-comment>  */

Line 5. printf("Hello World!");
The printf() statement is a library function under "stdio.h" library that displays information on-screen. The printf() statement can display a simple text message or the value of one or more program variables.

Syntax of printf() in printing literal text:
printf("<string-to-print>");

In the syntax, anything inside the " " double quotes is considered a literal text and will be printed on-screen. The <string-to-print> should be replaced with the text entries to be printed on-screen. The printf function must end with a ; semi-colon.

Line 5. getch();
The getch() "get character", is library function that accepts a character from the keyboard. The entered character however is not displayed on-screen. If the getch() is omitted from the code, the program will run, but upon printing the word "Hello World!", the program will immediately terminate. The program output closes immediately and may not be seen by the user. Hence the getch() is used as the trigger that when the output is presented on-screen, the user will have to press a key in the keyboard before the program terminates. The getch() is used as a terminator for the rest of the sample programs in this book. The getch() function must end with a ; semi-colon.
Note: The getch() and getche() functions are not a standard C functions as they are part of the conio library, but most C compilers supports this function including Dev-C++ and Turbo C. If you are using other compiler (especially for Linux OS) and the program does not run, you may ought to use getchar() instead of getch().

Writing, compiling, and running our first program
In writing the source file, open the Dev-C++ and create a new source file as presented in figure 2.2.


Enjoyed the sample? You may download the complete book at AMAZON.COM

Topics covered are:
Short history of C Language
Reasons to use C Language
Beginning to Program in C Language
Installing the Dev-C++
Self-assessment questions
Definition of programming terms
The components of a C program
Writing, compiling, and running our first program
Correcting errors
Statements
Null Statements
White spaces
Self-assessment questions
Variable
Variable Declaration and definition
Scope of variables
Constants
Keywords
Conversion specifiers of data types
Self-assessment questions
Displaying text on-screen
puts() function
printf() function
Literal text
An escape sequence
Accepting user input
getch() function
getche()  and getchar() functions
scanf() function
gets() function
Self-assessment questions
What is an Array?
Single-Dimensional
Multi-Dimensional Array
Strings
Declaring and defining a string
Defining a string using input functions
Strings' pre-defined functions
Length of a String
Concatenation of Strings
Compare Two Strings
Copy Strings
Reversing the Order of a String
Converting Uppercase Strings to Lowercase Strings
Converting Lowercase Strings to Uppercase Strings
Self-assessment questions
Expressions
Operators
Assignment Operator
Mathematical Operators
Binary
Unary
Mathematical operators precedence level and parentheses
Relational Operators
Logical Operators
Type Casting
Pre-defined Mathematical Functions
acos()
asin()
atan()
atan2()
cos()
cosh()
sin()
sinh()
tan()
tanh()
exp()
log()
log10()
pow()
sqrt()
ceil()
fabs()
floor()
fmod()
Self-assessment questions
The if() statement
Single-alternative
Dual-alternative
Multiple-alternative
Nested if() statement
The switch() statement
Things to consider in conditional statement
Self-assessment questions
What is a Loop?
Counter-controlled loop
for() loop statement
Nested for() loop statement
Condition-controlled loop
Pre-test loop
Post-test loop
The Infinite Loop
Self-assessment questions
User-defined function
User-defined function prototype
User-defined function definition
Calling a user-defined function
Things to consider in functions:
Self-assessment questions
Structures
Declaring a structure
Defining a structure
Accessing Structure Members
Compound declaration and definition of structure
Self-assessment questions
Pointers in C language
Pointer Declaration and definition
How pointers works?
Pointer Arithmetic
Self-assessment questions
File management in C
Defining and opening a file
Closing a File
Reading and writing a file
putc() and getc() functions
fprintf() and fscanf() functions
Deleting a File
Renaming a File
Self-assessment questions



Tuesday, June 7, 2016

Assembly Language: Simple, Short, and Straightforward Way of Learning Assembly Programming

Assembly Language:  Simple, Short, and Straightforward Way of Learning Assembly Programming


Chapter 1 - Introduction to Assembly Language

This chapter presents a brief introduction in assembly and the basic needed concepts in starting assembly programming to solve computer science related problems.

What is Assembly Language?
Assembly language is a low-level and the most basic programming language available for any processor. In assembly, programmers works directly on operations implemented on the computer's processor. Due to the nature of assembly language, it lacks high-level programming convenience since its far from human language like other high-level programming languages does. With assembly language, instructions like JMP @X, MOV AH, 09D, JNZ, DEC and many others are the codes that programmers deal with. At first glance, this codes does not represent any English like words, so learning assembly language can be quite a challenge for beginners. These are mnemonic codes that represents instructions and unlike other programming languages, in assembly, a certain code can represent several instructions which makes it more difficult.
Any computer has exactly two things on its foundation, a CPU and some Memory. These two makes computer programs run. The CPU reads the numbers one at a time, decodes them, and does what the numbers say, while the memory acts as the temporary storage location for the CPU. In assembly programming, programmers will deal with instructions implemented directly on the CPU and memory.

In the CPU Registers (for 32 bit), the 32 bit is the leftmost part of the register and the 16 bit is the rightmost part. Also the 16 bit are divided into two parts, the higher 8 bit and the lower 8 bit. Figure 1.1 presents the leftmost and rightmost illustration. All sample assembly codes and programs in this book uses only the 16 bit registers.

Figure 1.1 - Leftmost and rightmost composition of a register

1.  General Purpose Register
Figure 1.2 presents the general purpose registers which are available to the programmer.

Figure 1.2 - General purpose registers

As presented in figure 1.2, AX/EAX and DX/EDX both are used for input/output operations and AX/EAX and BX/EBX are also used for arithmetic computation. Note that AX, BX, CX, and DX are the 16 bit versions and EAX,EBX, ECX, and EDX are the 32 bit versions. Figure 1.3 presents the 32 bit and 16 bit areas of the general purpose registers.

Figure 1.3 - 32 bit and 16 bit composition

As presented in figure 1.3, the 16 bit registers are compose of two parts, the higher 8 bit and the lower 8 bit. The register AX comprises of AH (higher 8 bit) and AL (lower 8 bit), and so with the remaining 16 bit registers.

2. Segment Registers
Segments are specific areas defined in a assembly program for containing data, code and stack. There are three main segments which are:
2.1 Code Segment or CS Register contains all the instructions to be executed. A 16-bit Code Segment register stores the starting address of the code segment;
2.2 Data Segment or DS Register contains data, constants and work areas. A 16-bit Data Segment register stores the starting address of the data segment; and
2.3 Stack Segment or SS Register contains data and return addresses of procedures or subroutines. It is implemented as a 'stack' data structure. The Stack Segment register stores the starting address of the stack.

3. Pointer Registers
The 32 bit counterpart of pointer registers are EIP, ESP, and EBP registers and corresponding 16 bit counterpart are  IP, SP, and BP. There are three categories of pointer registers which are (the following focuses on 16 bit only):
3.1 Instruction Pointer (IP) is the 16 bit IP register which stores the offset address of the next instruction to be executed. IP in association with the CS register (as CS:IP) gives the complete address of the current instruction in the code segment.
3.2 Stack Pointer (SP) is the 16 bit SP register which provides the offset value within the program stack. SP in association with the SS register (SS:SP) refers to be current position of data or address within the program stack.
3.3 Base Pointer (BP) is the 16 bit BP register which mainly helps in referencing the parameter variables passed to a subroutine. The address in SS register is combined with the offset in BP to get the location of the parameter. BP can also be combined with DI and SI as base register for special addressing. Figure 1.4 presents the Pointer Registers.

4. Index Registers
The 32 bit counterpart of  index registers are ESI and EDI, and their 16 bit counterpart are SI and DI. Index Registers are used for indexed addressing and sometimes used in addition and subtraction. The two sets of index pointers are:
4.1 Source Index (SI) which is used as source index for string operations.
4.2 Destination Index (DI)  which is used as destination index for string operations.
Figure 1.5 presents the Index Registers.

5. Control Registers
Combining the 32 bit instruction pointer register and the 32 bit flags register are considered as the control registers. Many instructions involve comparisons and mathematical calculations may change the status of the flags and some other conditional instructions test the value of these status flags to take the control flow to other location. The common flag bits are:
5.1 Overflow Flag (OF) indicates the overflow of a high-order bit (leftmost bit) of data after a signed arithmetic operation.
5.2 Direction Flag (DF) determines left or right direction for moving or comparing string data. When the DF value is 0, the string operation takes left-to-right direction and when the value is set to 1, the string operation takes right-to-left direction.
5.3 Interrupt Flag (IF) determines whether the external interrupts like keyboard entry and others are to be ignored or processed. It disables the external interrupt when the value is 0 and enables interrupts when set to 1.
5.4 Trap Flag (TF) allows setting the operation of the processor in single-step mode. The DEBUG program we used sets the trap flag, so we could step through the execution one instruction at a time.
5.5 Sign Flag (SF) shows the sign of the result of an arithmetic operation. This flag is set according to the sign of a data item following the arithmetic operation. The sign is indicated by the high-order of leftmost bit. A positive result clears the value of SF to 0 and negative result sets it to 1.
5.6 Zero Flag (ZF) indicates the result of an arithmetic or comparison operation. A nonzero result clears the zero flag to 0, and a zero result sets it to 1.
5.7 Auxiliary Carry Flag (AF) contains the carry from bit 3 to bit 4 following an arithmetic operation; used for specialized arithmetic. The AF is set when a 1-byte arithmetic operation causes a carry from bit 3 into bit 4.
5.8 Parity Flag (PF) indicates the total number of 1-bits in the result obtained from an arithmetic operation. An even number of 1-bits clears the parity flag to 0 and an odd number of 1-bits sets the parity flag to 1.
5.9 Carry Flag (CF) contains the carry of 0 or 1 from a high-order bit (leftmost) after an arithmetic operation. It also stores the contents of last bit of a shift or rotate operation.
Example programs used in this book will not cover the above mentioned flags.


Chapter 2 - Our First Assembly Program

This chapter gives a quick glimpse on coding instructions in assembly. This chapter deals with assembler installation, writing codes, and running our very first assembly program.

Assembly Program Structure
Codes in assembly language are not case sensitive. The instruction MOV and mov means the same. In this book all reserved words and labels are coded in uppercase and all other user-defined codes are in lower case for readability purpose.

Fundamentals of Assembly Instructions
An instruction is a statement that is executed by the processor at runtime after the program has been loaded into memory and started. An instruction format contains three basic parts:
1. Mnemonic Code (required)
2. Operand(s) (usually required)
3. Comment (optional)

Figure 2.1: Assembly instructions usual format

Mnemonic Code
The mnemonic code is a short word that identifies the operation carried out by an instruction.

Operands
The operands are instructions which could have between zero to three operands, each of which can be a register, memory operand, constant expression, or I/O port.

Comments
Comments are a short description of the codes purpose. A way for the programmer to communicate information about how the code works to a person reading the source code.

Example 1: MOV AH,9D     ;Displays string
Explanation: MOV is an example of a mnemonic code instruction in assembly. The instruction MOV requires two operands separated by comma. We can say that AH is the first operand and 9D is the second operand. ;Display string is the comment. Comments are ignored by the assembler and will not affect the output of the program. Comments are used as internal documentation for the programmers reference of what the code does. It is a good practice in assembly to add comments as assembly codes does not usually represent English words.
Example 2: INT 21H    ;Calls DOS service
Explanation: INT is another example of a mnemonic code instruction in assembly. The instruction INT requires only one operand and in this example 21H is the operand. ;Call Dos service is the comment.

The MOV instruction appears to be shorthand for the word "Move". This makes a lot of sense as this instruction move from source to destination. However, the MOV instructions does not really moves the value from the source to the destination, instead it copies the value of the source to the destination. The syntax is presented in figure 2.2

Figure 2.2: Format of the MOV instruction

In figure 2.2, the destination can either be a register or memory address, and the source can be a register, memory address, or immediate value.
Example: MOV AH, 9D
Explanation: In the  example, it copies the source with the value 9D (D means decimal),  to the destination Register AH. This means that AH now holds the value 9D.

INT stands for interrupt. INT is an assembly language instruction for x86 processors that generates a software interrupt. Figure 2.3 presents the syntax of the INT instruction.

Figure 2.3: Format of the INT instruction

Example: INT 21H
Explanation: The example calls the software interrupt 21H (H means Hexadecimal) which is the DOS service. This usually returns the program to DOS. Other software interrupts and mnemonic codes are discussed in the succeeding chapters of this book.
The assembly program structure can be best explained with example.  Figure 2.4 is a sample program that prints the word "Hello World!" into the screen.



Note that the numbers in the leftmost part are just line numbers, hence not a part of the program code.

;<Code listings in Figure 2.4 - START>
.MODEL SMALL
.STACK
.DATA
Message DB "Hello World!$"
.CODE
MAIN:                   ; Below are comments
MOV DX,OFFSET Message ; Offset of Message is in DX
MOV AX,SEG Message   ; Segment of Message is in AX
MOV DS,AX            ; DS:DX points to string
 
MOV AH,9D            ; Function 9D displays string
INT 21H              ; Calls dos service
 
MOV AH, 4CH          ; Code to terminate the program
INT 21H              ; Calls dos service
END MAIN
;<Code listings in Figure 2.4 - END>

Explanation of code listings in figure 2.4
The ";" <semi-colon> is for comments for each line wherein anything that follows the ";" are ignored by the assembler, hence it will not affect the output of the program.
Line 1: .MODEL
It is an Assembler directive that defines the memory model to use in the program. Basically, memory models defines how big the program is. The bigger the program, the bigger model should be defined. The different memory models in assembly are:
a. TINY. This means that there is only one segment for both code and data. This type of program can be a .com file;
b. SMALL. This means that by default all code is place in one segment and all data declared in the data segment is also placed in one segment which means that all procedures and variables are addressed as NEAR by pointing at offsets only. SMALL is the MODEL that were used for all sample programs in this book;
c. COMPACT. This means that by default all elements of code are placed in one segment but each element of data can be placed in its own physical segment which means that data elements are addressed by pointing at both at the segment and offset addresses. Code elements (procedures) are NEAR and variables are FAR;
d. Medium. This is the opposite to compact. Data elements are NEAR and procedures are FAR;
e. Large. This means that both procedures and variables are FAR. It is needed to point at both the segment and offset addresses; and
f. FLAT. This isn't used much as it is for 32 bit unsegmented memory space. For this, DOS extender is needed. This is what is needed to be used  in writing a program to interface with a C/C++ program that used a DOS extender such as DOS4GW or PharLap.

Line 2: .STACK
It is an Assembler directive that reserves a memory space for program instructions in the stack. This directive is used for stack based programs which is discussed in the succeeding chapters of this book.

Line 3: .DATA
It indicates that the data segment starts here and that the stack segment ends there. This directive is where we declare and/or assign value to a storage similar to variable declaration and definition (assigning value to a variable) in high-level language.

Line 4: Message DB "Hello World!$"
Message is the variable name declared (user-defined) with a memory directive (define directive) of DB which stands for DefineByte (used for all programs in this book), and the value assigned to the variable Message is "Hello World!". The $ <dollar sign> is a string terminator, which means that it will not be printed in the screen. If $ is miss out, it will result to random characters printed on the screen, since the end of the string is not defined. The list of memory-directives (define directives) is presented in table 2.1


Enjoyed the reading? 

The following are the entire contents:


1.1 What is Assembly Language?
1.2 CPU REGISTERS
1.2.1 General Purpose Register
1.2.2 Segment Registers
1.2.3 Pointer Registers
1.2.4 Index Registers
1.2.5 Control Registers
2.1 Assembly Program Structure
2.1.1 Fundamentals of Assembly Instructions
2.1.2 The MOV instruction in Assembly
2.1.3 The INT instruction in Assembly
2.1.4 Reserved words in assembly
2.2 Running our first Assembly program
2.2.1 How to install TASM?
2.2.2 Writing the Assembly Program Codes
2.2.3 Compiling (Assembling), Linking and Running the Program              
3.1 Simplified Segment Directives
3.2 Output Routines
3.3 Input Routines
4.1 Introduction to Arithmetic Instruction
4.2 The ADD Instruction (Addition)
4.3 The SUB Instruction (Subtraction)
4.4 The INC Instruction (Increment)
4.5 The DEC Instruction (Decrement)
4.6 The IMUL and MUL Instructions (Multiplication)
4.7 The IDIV and DIV Instructions (Division)
4.8 Handling numeric data
4.8.1 Algorithm in printing 2 digit number
4.8.2 Algorithm in printing 3 digit number
4.8.3 Algorithm in accepting 2 digit number
4.8.4 Algorithm in accepting 3 digit number
5.1 Conditional Control
5.1.1 Conditional Jumps
5.1.2 Unconditional Jump
5.2 Loop Control
5.2.1 Conditional Loop
5.2.2 Counter Controlled Loop
6.1 What is Stack?
6.1.1 PUSH operation
6.1.2 POP operation
6.2 Stack Simulation
6.3 Stack Oriented Program
7.1 Defining a Procedure
7.2 Calling a Procedure
7.3 Procedure Oriented Program
8.1 OddEven Program
8.2 Legal Age Program
8.3 Alphabet Program

List of sample programs:


You may read the entire contents at https://www.amazon.com/dp/B01GQE4DS8








My Book Listings

Greetings!
 The following are my book listings available for purchase at amazon.com. Click the link and get redirected.

 1.


            The Student Information Source File is available at a minimal fee of $0.99. Click Donate and get redirected afterwards.


 2.



3. 


           The sample source files is available here at minimal fee of $0.99. Click Donate and get redirected afterwards.



4.




5.


C language Programming: Simple, Short, and Straightforward Way of Learning C Language Programming

  The sample source files is available here at minimal fee of $0.99. Click Donate and get redirected afterwards.




6.


C++ Programming Language: Simple, Short, and Straightforward Way of Learning C++ Programming

  The sample source files is available here at minimal fee of $0.99. Click Donate and get redirected afterwards.