Untitled Document

 Welcome and join ACQVIN group. 

Job Training


We Train you in Unix, Perl, R, SQL, SAS, Statistics, JAVA, QA/Testing



LINUX Installation and Getting Started

Introduction to the Linux Operating System

UNIX Environment

UNIX Shell Architecture and Shell Scripting

UNIX commands

File system, Operations and Management

Managing Files and Directories

Permissions - Files and Directories

UNIX Variables

UNIX Expressions and Operators

UNIX Control statements and Loop Types

UNIX Process Management

UNIX - System Administration

UNIX Utilities and Communication



Installation of Perl

Installation of Perl Packages

Basic Concepts in Perl

Perl Data Types

Perl variables

Perl Operator and Control Statements

Perl Subroutines

Perl programming

Object Oriented Programming

Perl Modules

Applications of Perl: Bioperl



Installation of RP

Fundamentals of R

R Basic commands

Scripting in R

R Data Objects - Matrices, Data frames, Vectors

R Functions

Graphical analysis with R

Statistics with R

Applications of R - Bioconductor



Installation of MySQL

Introduction to SQL and MySQL Database

Relational Database Concepts

SQL Language

SQL SELECT Statements

SQL Functions and Expressions

Querying Data with SQL

SQL Joins

SQL Updating Records

SQL Summarization

Creating views

Creating Tables

Creating Database



Introduction to SAS

SAS Data Structure


Rules for SAS Names

Rules for SAS Statements

INFILE and INPUT Statement

Set Statement

IF/THEN and IF/THEN...ELSE Statement

Subsetting IF Statement

LIBNAME Statement

MERGE Statement

SAS Procedure Step

PROC Contents

PROC PRINT Statement


PROC SORT Statement

PROC FREQ Statement

PROC MEANS Statement

SAS Functions




Statistical Methods

Data Types

Data Representation

Descriptive Statistics

Inferential Statistics

Correlation and Regression

Probability and Distributions

Hypothesis Testing

Parametric and Non-parametric Tests

Statistical Software Tools

Application of Statistics - Biostatistics


 JAVA- Training Syllabus

Object-Oriented Programming Concepts
          What Is an Object?
          What Is a Class?
          What Is Inheritance?
          What Is an Interface?
          What Is a Package?
          Questions and Exercises: Object-Oriented Programming Concepts
Language Basics
          Primitive Data Types
         Summary of Variables
          Questions and Exercises: Variables

            Assignment, Arithmetic, and Unary Operators
            Equality, Relational, and Conditional Operators
            Bitwise and Bit Shift Operators
            Summary of Operators
           Questions and Exercises: Operators

Expressions, Statements, and Blocks
         Control Flow Statements
            The if-then and if-then-else Statements
            The switch Statement
            The while and do-while Statements
            The for Statement
            Branching Statements
            Summary of Control Flow Statements
          Questions and Exercises: Control Flow Statement

Questions and Exercises: Expressions, Statements, and Blocks

Classes and Objects
            Declaring Classes
            Declaring Member Variables
            Defining Methods
            Providing Constructors for Your Classes
            Passing Information to a Method or a Constructor
            Creating Objects
            Using Objects
        More on Classes
            Returning a Value from a Method
            Using the this Keyword
            Controlling Access to Members of a Class
            Understanding Class Members
            Initializing Fields
            Summary of Creating and Using Classes and Objects
          Questions and Exercises: Classes
          Questions and Exercises: Objects

Nested Classes
            Inner Class Example
            Local Classes
            Anonymous Classes
            Lambda Expressions
            Method References
            When to Use Nested Classes, Local Classes, Anonymous Classes, and     Lambda

        Questions and Exercises: Nested Classes
        Enum Types
        Questions and Exercises: Enum Types
        Annotations Basics
        Declaring an Annotation Type
        Predefined Annotation Types
        Type Annotations and Pluggable Type Systems
        Repeating Annotations
        Questions and Exercises: Annotations

Interfaces and Inheritance
            Defining an Interface
            Implementing an Interface
            Using an Interface as a Type
            Evolving Interfaces
            Default Methods
            Summary of Interfaces
          Questions and Exercises: Interfaces
            Multiple Inheritance of State, Implementation, and Type
            Overriding and Hiding Methods
            Hiding Fields
            Using the Keyword super
            Object as a Superclass
            Writing Final Classes and Methods
            Abstract Methods and Classes
            Summary of Inheritance
                   Questions and Exercises: Inheritance

Numbers and Strings
            The Numbers Classes
            Formatting Numeric Print Output
            Beyond Basic Arithmetic
            Summary of Numbers
            Questions and Exercises: Numbers Characters
            Converting Between Numbers and Strings
            Manipulating Characters in a String
            Comparing Strings and Portions of Strings
            The StringBuilder Class
            Summary of Characters and Strings
                   Autoboxing and Unboxing
                   Questions and Exercises: Characters and Strings

Generics (Updated)
          Why Use Generics?
          Generic Types
            Raw Types
          Generic Methods
          Bounded Type Parameters
            Generic Methods and Bounded Type Parameters
          Generics, Inheritance, and Subtypes

Type Inference
            Upper Bounded Wildcards
            Unbounded Wildcards
            Lower Bounded Wildcards
            Wildcards and Subtyping
            Wildcard Capture and Helper Methods
            Guidelines for Wildcard Use

Type Erasure
            Erasure of Generic Types
            Erasure of Generic Methods
            Effects of Type Erasure and Bridge Methods
            Non-Reifiable Types
          Restrictions on Generics
          Questions and Exercises: Generics

          Creating and Using Packages
            Creating a Package
            Naming a Package
            Using Package Members
            Managing Source and Class Files
            Summary of Creating and Using Packages
          Questions and Exercises: Creating and Using Packages


 Quality Assurance/Testing- Training Syllabus


  • Manual testing
  • Automated testing
  • VIDEOS for every class that you attend / 1 year access to the exclusive videos / new additional videos addedevery day 
  • Testing Methodologies~ WATER FALL /AGILE METHODOLOGY 
  • Real time QA experiences real time discussions
  • Real time testing exercises step by step procedures,
  • 100s of Interview Questions , Every Day discussions discussions
  • every day mock interviews in the class itself. 
  • One to One training available for freshers.



  • Adding Test Requirement Characteristics of a useful requirement
  • Example of a Test Requirement
  • Building a requirements structure Entering requirements
  • Manually Importing requirements
  • Requirements graphs and reports
  • Adding Test Cases,
  • Test case coverage
  • Characteristics of a useful test case Test Case
  • Example Building a test case structure
  • Creating manual test cases
  • Parameters Importing test cases
  • Linking test cases to requirements
  • Test case graphs
  • and reports
  • Test Sets and Test Execution
  • Creating test sets Defining
  • test dependencies and running tests conditionally
  • Setting test set properties
  • Manual test execution
  • Automated test execution,
  • Adding test hosts
  • Running a test set



Payments can be made online using Paypal Payments

Make payments with payPal - it's fast, free and secure!

Enter Amount

We give 100% Satisfaction Guarantee.