Before we begin, let me defend the somewhat outrageous title of this article with an analogy: You can make
your own bread with a prepackaged mix, a bread machine and some electricity—or, you can assemble the raw
ingredients, a mixing bowl, a stout spoon, a dough blade, fire up the oven and get some cardio through
kneading. If it’s just fresh bread you’re after, the machine gets you there.
But if you want to understand the underlying process and have the most options when it comes to the final
product, you need to put in the effort of the manual method. This is a lot like tackling the C programming
language: You have to dig down into the flour and get your hands dusty, but you end up understanding the
process at an intimate level.
First, let’s make a distinction between someone who wants to just learn any programming language (the guy
who just wants the bread) from someone who has the desire to be a polyglot programmer (the artisan baker).
Don't get me wrong, there are many great reasons to learn a programming language, and even if you just learn
one higher level scripting language like Python or JavaScript, you’re still a programmer. Mastering any
single language is still a challenge and a worthy goal.
However, the programmer I’m addressing here is someone who wants to understand programming at a deeper level
just for programming’s sake. This is someone who naturally has a desire to become that polyglot programmer.
Originally, I wanted to title this article “Why Every Programmer Should Learn C First,” but I backed away
from that. Sure, there are advantages to learning C first; you won’t get seduced by a language like Python
and never come back. In fact, if I were teaching high school students, I would almost certainly teach them a
higher level language like Python first. Then I would take my best students and teach them C second. If I
were teaching a class of science and engineers, I would probably just start with C. Let’s face it, if they
learned Maxwell’s equations, a little pointer indirection isn’t going to induce a lot of angst.
However, I do think there are advantages to learning C first over C++ or Java. When you work in languages
like Java, C# and even Python, you immediately start moving away from learning the fundamentals of a
programming language and you start learning associated libraries and frameworks. But with C you get a few
library calls, you stay focused on the semantics of the language longer, and C often forces you to think
harder and deeper about what’s happening under the hood.
C is a middle level language. When people talk about it you’ll hear phrases like “coding to the metal,” or
“coding close to the wire”. C is the language of compilers, interpreters, editors, operating systems and
embedded programming When you learn to program in C you almost have to gain an understanding of how
programs execute. You know what things like register, stack, heap and memory mapped IO mean. You start to
think how much better life would have been if you had been born with sixteen fingers.
C is simple, elegant and wicked fast; it’s compact and efficient. Because C has raw pointers, bitwise
operators, and the keywords: extern, volatile, static, and register—meaning you’ll understand more about
writing efficient code than you can glean from any higher-level language. The only thing that will teach
you these things any better is a low-level language, and with modern processors I wouldn’t wish assembler
on anyone.
The C syntax is why programmers talk about the “C Family of Languages,” which generally includes languages
like: C, C++, C#, Java, EcmaScript (aka JavaScript), Objective-C and many others. Wikipedia lists plenty
more, but I think their list is a bit wacky.
C also happens to be demanding, fastidious, finicky and sometimes downright cryptic. You can easily write hard-to-read, difficult to maintain code in C. But and this is a key point, you don’t have to Learning to write maintainable code in C will require (and hopefully instill) coding discipline. In most languages fixing syntax errors can border on the trivial For instance, Ada’s compiler error messages are so good it might as well have just fixed the code for you. Finding and correcting a missing or additional semicolon in C can sometimes be an epic undertaking.
C is not an object-oriented language, so you don’t get distracted by things like inheritance and polymorphism. I’m not saying these aren’t important concepts, it’s just that you can simplify things a bit by learning straight procedural programming first. In fact, once you've learned C, and written a couple of embedded programs on some single board computers, learning C++ is a natural next step. You will need to get someone to pry your fingers off the macros and preprocessor directives but other than that it will be straightforward. I would be tempted to teach C with a C++ compiler, and just highlight the few differences that weren’t backwards compatible with a strict C compiler.
My final argument for learning C is tied to doing embedded programming. As a programmer, I always get a sense of satisfaction when I deliver any working piece of code. Making a computer do what you want can be satisfying. But when I integrate my embedded code with some custom hardware that makes things happen outside of the computer—from moving a robotic arm to generating a precisely timed waveform—I get an incomparable thrill. That thrill only happens because I learned C Of course, I ended up doing most of my embedded coding in C++ but I still felt that learning C first made it all possible. If you want a fast pleasant way to learn C, Sigma-PI Academy has you covered, check out my Course on The C Programming Language in Action.
Introduction to components of a computer system: Memory, processor, I/O Devices, storage, operating
system, Concept of assembler, compiler, interpreter, loader and linker
Idea of Algorithm: Representation of Algorithm, Flowchart, Pseudo code with examples, From
algorithms to programs, source code
Programming Basics: Structure of C program, writing and executing the first C program, Syntax and
logical errors in compilation, object and executable code
Components of C language: Standard I/O in C, Fundamental data types, Variables and memory
locations, Storage classes
Arithmetic expressions and precedence: Operators and expression using numeric and relational
operators, mixed operands, type conversion, logical operators, bit operations, assignment operator,
operator precedence and associativity
Conditional Branching: Applying if and switch statements, nesting if and else, use of break and
default with switch
Iteration and loops: use of while, do while and for loops, multiple loop variables, use of break and
continue statements
Functions: Introduction, types of functions, functions with array, passing parameters to
functions, call by value, call by reference, recursive functions
Arrays: Array notation and representation, manipulating array elements, using multi-dimensional arrays
Character arrays and strings, Structure, union, enumerated data types, Array of structures, Passing
arrays to functions
Basic Algorithms: Searching & Basic Sorting Algorithms (Bubble, Insertion and Selection), Finding
roots of equations, Notion of order of complexity
Pointers: Introduction, declaration, applications, Introduction to dynamic memory allocation (malloc,
calloc, realloc, free), Use of pointers in self-referential structures, notion of linked list (no
implementation)
File handling: File I/O functions, Standard C preprocessors, defining and calling macros,
command-line arguments
C++ is a general-purpose, object-oriented programming language that was designed by Bjarne Stroustrup in to be an extension of the C language It has the features of imperative, object-oriented as well as generic programming models C++ also has some additional facilities to those in C such as classes, inheritance, default function argument, etc C++ plays quite an integral role in modern times as many contemporary systems such as operating systems, web browsers, databases, etc have C++ code in at least some part of their codebase Moreover, C++ is quite useful in performance critical areas because of its speed Keeping the popularity and relevance of C++ in mind, the top reasons to learn it are given below:
C++ is one of the most popular languages in the world It is used by some million developers worldwide Also, C++ Developers are quite sought after and they hold some of the most high-paying jobs in the industry with an average base pay of $ , per year.
C++ has the Standard Template Library(STL) that is very useful as it helps in writing code compactly and quickly as required It contains mainly four components i e algorithms, containers, functions, and iterators The algorithms are of different types such as sorting, searching, etc The containers store classes to implement different data structures that are commonly used such as stacks, queues, hash tables, vectors, sets, lists, maps, etc The functors allow the working of the associated function to be customized with the help of the parameters passed Also, the iterators are used for working upon a sequence of values.
There is a large online community of C++ users and experts that is particularly helpful in case any support is required. There is a lot of resources like GeeksforGeeks etc available on the internet regarding C++. Some of the other online resources for C++ include StackOverflow, cppreference com, Standard C++, etc.
There are many modern-day databases such as MySQL, MongoDB, MemSQL, etc that are written in C++. This is because C++ is quite modern and it supports features like exceptions, lambda expressions, etc. Many of the databases that are written in C++ are used in almost all of the in-use applications such as YouTube, WordPress, Twitter, Facebook, etc.
All the major operating systems such as Windows, Linux, Android, Ubuntu, iOS, etc are written in a combination of C and C++. The Windows applications are written in C++, while Android applications are written in Java along with C/C++ with non-default run-times for C++ support. Also, C++ can be used to develop the core of the applications in iOS .In general, C or C++ are used in operating systems because of the speed and strongly typed nature of these languages.
C++ is closer to the hardware level and is a comparatively low-level language. Because of this reason, it is used in many compilers as a backend programming language. An example of this is the GNU Compiler Collection (GCC) which is currently written mostly in C++ along with C.
A lot of web browsers are developed using C++ such as Chrome, Firefox, Safari, etc Chrome contains C++ in the rendering engine, JavaScript engine, and the UI Firefox uses mainly in the rendering engine and a little in the UI Safari also uses C++ in the rendering engine and JavaScript engine All these web browsers and more use C++, particularly in the rendering engines because it provides the required speed that is necessary for the rendering engines since they need to display the content at an accelerated rate.
Applications requiring graphics such as digital image processing, computer vision, screen recording programs, etc use C++ due to its high speed. This can also include different games that have graphics as a big part of their structure .
C++ is closer to the hardware level and so it is quite useful in embedded systems as the software and hardware in these are closely coupled. There are many embedded systems that use C++ such as smart watches, MP players, GPS systems, etc .
Programs developed in C++ can be moved from one platform to another. This is one of the main reasons that applications requiring multi-platform or multi-device development often use C++ .
Block Structure of C and C++ Programs
Fundamentals of Syntax
Built in Data Types
The Preprocessor and Macros
Data Types and Qualifiers
Constants and String Literals
Static versus Automatic Storage
Scope and variables
Initialization Rules
Arithmetic, Logical, and Bit Operators
Precedence and associativity
Assignment
Type Conversion Rules
Type Casting
Conditional Constructs: if, switch
Looping Constructs: while, do, for
Programming Style
Advantages of Pointers
Uses of Pointers
Declaring Pointers
Pointer and Address Arithmetic
Initializing and Dereferencing Pointers
Pointers vs. Arrays
New Compiler Directives
Stream Console I/O
Explicit Operators
Standard Libraries
Data Control Capabilities
New Declaration Features
Initialization and Assignment
Enumerated Types
The bool type
Constant Storage
Pointers to Constant Storage
Constant Pointers
References
Constant Reference Arguments
Volatile Data
Global Data
Function Prototypes and Type Checking
Default Function Data Types
Function Overloading
Problems with Function Overloading
Name Resolution
Promotions and Conversions
Call by Value
Reference Declarations
Call-by-Reference and Reference Types
References in Function Return
Constant Argument Types
Conversion of Parameters Using Default Initializers
Providing Default Arguments
Inline Functions
Character Strings
The String Class
Operators on Strings
Member Functions of the String Class
Creating Automatic Objects
Creating Dynamic Objects
Calling Object Methods
Constructors
Initializing Member consts
Initializer List Syntax
Allocating Resources in Constructor
Destructors
Block and Function Scope
File and Global Scope
Class Scope
Scope Resolution Operator (::)
Using Objects as Arguments
Objects as Function Return Values
Constant Methods
Containment Relationships
Advantages of Dynamic Memory Allocation
Static, Automatic, and Heap Memory
Free Store Allocation with new and delete
Handling Memory Allocation Errors
Object Copying and Copy Constructor
Automatic Copy Constructor
Conversion Constructor
Inheritance and Reuse
Composition vs. Inheritance
Inheritance: Centralized Code
Inheritance: Maintenance and Revision :
* Public, Private and Protected Members
* Redefining Behavior in Derived Classes
* Designing Extensible Software Systems
Syntax for Public Inheritance
Use of Common Pointers
Constructors and Initialization
Inherited Copy Constructors
Destructors and Inheritance
Public, Protected, Private Inheritance
Streams and the iostream Library
Built-in Stream Objects
Stream Manipulators
Stream Methods
Input/Output Operators
Character Input
String Streams
Formatted I/O
File Stream I/O
Overloading Stream Operators
Persistent Objects
The Object Programming Paradigm
Object-Orientated Programming Definitions
Information Hiding and Encapsulation
Separating Interface and Implementation
Classes and Instances of Objects
Overloaded Objects and Polymorphism
Purpose of Template Classes
Constants in Templates
Templates and Inheritance
Container Classes
Use of Libraries
Types of Exceptions
Trapping and Handling Exceptions
Triggering Exceptions
Handling Memory Allocation Errors
Organizing C++ Source Files
Integrating C and C++ Projects
Using C in C++
Function Prototypes
Strong Type Checking
Constant Types
C++ Access Control Techniques
Definition of Polymorphism
Calling Overridden Methods
Upcasting
Accessing Overridden Methods
Virtual Methods and Dynamic Binding
Virtual Destructors
Abstract Base Classes and Pure Virtual Methods
Derivation from Multiple Base Classes
Base Class Ambiguities
Virtual Inheritance
* Virtual Base Classes
* Virtual Base Class Information
Components of a class
Class Structure
Class Declaration Syntax
Member Data
Built-in Operations
Constructors and Initialization
Initialization vs. Assignment
Class Type Members
Member Functions and Member Accessibility
Inline Member Functions
Friend Functions
Static Members
Modifying Access with a Friend Class
Advantages and Pitfalls of Overloading
Member Operator Syntax and Examples
Class Assignment Operators
Class Equality Operators
Non-Member Operator Overloading
Member and Non-Member Operator Functions
Operator Precedence
The this Pointer
Overloading the Assignment Operator
Overloading Caveats
STL Containers
Parameters Used in Container Classes
The Vector Class
STL Algorithms
Use of Libraries
Java is one of the most popular languages in the world. It is used by some million developers and it runs on around billion devices worldwide according to Oracle blogs. Because of the high demand for Java, Java developers are also quite sought after and they hold some of the most high-paying jobs in the industry.
Java has an abundant Application Programming Interface (API) that includes many Java classes, packages, interfaces, etc This is useful for constructing applications without necessarily knowing their inside implementations Java has mainly three types of API i e Official Java core API’s, Optional official Java API’s and Unofficial API’s These API’s overall are used for almost everything including networking, I/O, databases, media, XML parsing, speech synthesis, etc .
Open source libraries have resources that can be copied, studied, changed, shared, etc There are multiple open source libraries in Java such as JHipster, Maven, Google Guava, Apache Commons, etc that can be used to make Java development easier, cheaper and faster.
There are many Integrated development environments (IDE’s) in Java that provides various facilities for software development to programmers Powerful Java IDE’s such as Eclipse, NetBeans, IntelliJ IDEA, etc play a big role in the success of Java These IDE’s provide many facilities such as debugging, syntax highlighting, code completion, language support, automated refactoring, etc that make coding in Java easier and faster Java has created a base for the Android operating system and opted around fortune companies for develop a lot of back-end applications Also, it plays a great role in Apache Hadoop data processing, Amazon Web Services, and Windows Azure, etc .
One of the reasons Java is very popular among individual programmers is that it is available under the Oracle Binary Code License (BCL) free of charge. This means that Java is free for development and test environments, but for commercial purposes, a small fee is required.
Java is platform independent as the Java source code is converted to byte code by the compiler which can then be executed on any platform using the Java Virtual Machine Java is also known as a WORA (write once, run anywhere) language because it is platform independent. Also, the development of most Java applications occurs in a Windows environment while they are run on a UNIX platform because of the platform independent nature of Java .
The documentation support for Java is excellent using Javadoc which is the documentation generator for Java It uses the Java source code to generate the API documentation in HTML format So, Javadoc provides a great reference while coding in Java so that understanding the code is quite simple.
Java is very versatile as it is used for programming applications on the web, mobile, desktop, etc using different platforms Also, Java has many features such as dynamic coding, multiple security features, platform-independent characteristics, network-centric designing, etc that make it quite versatile.
COURSE DURATION: 40 WEEKS
In this course the student will become proficient core java programmer, and can develop Graphical
Application, Games and can go for Android App Development.
⇒ Video recording of every class.
⇒ Pdf of the class notes.
⇒ Regular tests will be taken and we would work on the weakpoint of the student.
⇒ Doubt clearing at the time when the student is unable to solve the problem.
1. Introduction to Java Language
2. Fundamental Data Types
3. Decisions
4. Loops
5. Methods
6. Arrays and Array Lists
7. Input/Output and Exception Handling
8. Objects and Classes
9. Inheritance and Interfaces
10. The Java Collections Framework
11. Multithreading
12. Graphical User Interfaces
13. Advanced Graphical User Interfaces
14. Introduction to IDE like Eclipse and NetBeans
15. Object-Oriented Design
16. Recursion
17. Sorting and Searching
18. JavaFX
⇒ Introduction to Java FX
⇒ Colors and Shapes
⇒ Graphics, Audio, and MouseEvents
19. Final Project
⇒ a. Developing a Java-based animation, application or game
COURSE DURATION : 60 Hours
PREREQUISITE : Core Java Course of SigmaPi Academy
In this Course we focus on JDBC meaning we connect to the database software and perform many operations.
This knowledge is useful in developing enterprise level software.
⇒ Video recording of every class.
⇒ Pdf of the class notes.
⇒ Regular tests will be taken and we would work on the weakpoint of the student.
⇒ Doubt clearing at the time when the student is unable to solve the problem.
1. Introduction to advanced Java
2. JDBC in simple way
3. Storage Areas
4. Introduction to JDBC
5. JDBC Architecture
6. JDBC API
7. Driver Interface vs Driver Class vs Driver Software
8. Types of Driver
9. Standard steps to develop JDBC Applications.
10. Working with Type-1 Driver.
11. Working with Type-2 Driver.
12. Working with Type-3 Driver.
13. Working with Type-4 Driver.
14. Working with Type-5 Driver.
15. Summary table of all 5 JDBC drivers.
16. Program to create and drop table.
17. How to read dynamic input from the keyboard.
18. How to form SQL queries with dynamic input.
19. Program for Basic CRUD operation.
20. Realtime coding standard for JDBC application.
21. How to develop & run JDBC Application with Netbeans IDE.
22. Working with mysql database.
23. Life cycle of SQL query executor.
24. Prepared Statement.
25. Difference between Statement and Prepared Statement.
26. SQL Injection Attack.
27. Stored Procedures.
28. Callable Statement.
29. Cursors
30. Functions.
31. Statement vs Prepared Statement vs Callable Statement.
32. Batch Updates.
33. executeQuery() vs executeUpdate() vs execute() vs executeBatch()
34. Insert and retrieve Date values.
35. BLOB & CLOB Introduction.
36. Insert & Retrieve BLOB type .
37. Insert & Retrieve CLOB type.
38. Connection Pooling.
39. Working with Properties.
40. Different ways to get connection object.
41. Transaction Management.
42. Savepoints.
43. Transaction Concurrency Problem and Isolation level.
44. MetaData :
⇒ Database Metadata
⇒ ResultSet Metadata
⇒ Parameter Metadata
45. JDBC with non-Traditional Database like Excel.
46. ResultSet Types :
⇒ Forward only and Scrollable
⇒ Scroll Sensitive & Scroll insensitive
⇒ Read only & updatable
47. ResultSet Holdablity.
48. RowSet vs ResultSet.
49. Working with all RowSets.
50. Miscellaneous topics like RowId etc.
Imagine that you want to make an app which searches in a specific city for the shortest road to reach a specific destination case you are late, note that here you are late, which means you can’t wait, simply the answer for that problem is that, try every road and minimize the length, finally tell the user the path with the minimum path, which will take a lot and a lot of time, and you can’t wait, so you need a specific method or “algorithm” to do this fast. This is a simple example, a lot of other problems may take hours or days to be solved with the native solution, it also may take years! can you imagine? The same thing with algorithms, some ways to store data makes it easy to be manipulated easier and faster which is what you want, for example assume that you have a system which generates generous values to your ratio of sugar in your blood, it takes a record for every second, and warns you with the lowest value, you can implement it using vector, and every once you add a record, you go calculate the minimum, that takes a lot of time, on that other hand you can use priority queue which keeps the lowest value itself.
Without a good knowledge of various data structures, it is easy to be constrained to thinking for solutions in terms of the data structures directly provided by the language If you were a Java programmer, you’d probably be thinking on solutions just in terms of what is provided in java lang util package Well, there’s lots more Take for instance a simple need: In a low end, basic phone, as the user types something, you’d like to present the user with “auto complete” feature Thinking in terms of the data structures readily provided by the language /libraries doesn’t help much.
No amount of additional hardware is going to compensate for an inefficient algorithm Super computer takes
week to sort a billion numbers using insertion sort whereas a home computer takes minutes sort a billion
numbers using merge sort.
Insertion Sort: O(n*n)
Merge Sort: O(n log n)
Given an array with n distinct elements and n copies of another element. Find the missing element : Well,
the normal solution we would all think of is to do a linear scan through the array and to find the missing
element after reading through n/ + elements at the worst case [ Worst case = all n/ distinct numbers appear
first in the array and then the number-which-repeats appears n/ times]
Interestingly, this could be solved faster this way :
while(true) do
i = Rand numberWithinRange(to n)
j = Rand numberWithinRange(to n)
if(i!=j) and a[i]=a[j] then return i;
And the probability that the algorithm does not quit in iterations is !
“Randomization” turns out to be an amazing practical way of solving some section of problems
And to give a more “real-world’s application for “randomization” -The randomized version of quicksort is one
of the most practical/ efficient sorting algorithms !
Get ready to be surprised by lots of cool, non-intuitive-yet-amazing ways of solving problems.
It’s interesting to get back to some math, – specifically on probability, expectations, logarithm.
While learning different algorithms, you’d also be grasping the different algorithm design paradigms (Divide and Conquer, Greedy method, Backtracking, Dynamic Programming) When there’s a new problem to be solved, this knowledge helps to come up with an efficient solution.
Certain things are just “knowledge” – that could be learned-along-the-way when a need arises For example: There’s not really a need to know all the “MVC” frameworks out there Knowing one is just enough There’s a need to use some other MVC framework ? Well that could be learned along the way But algorithms and data structures don’t fall into that category It’s a skill, to deduce an algorithm for a problem / It’s a skill to analyse the complexity and tell which algorithm is the better one / It’s good to learn in advance Acquiring a skill is interesting, right?
Without some learning of algorithms, it’s quite possible that we come up with inefficient solutions when an efficient one already exists!
Almost every tool that we use, day after day, applies some cool algorithms.
1. Introduction :
⇒ Algorithm Specification; Performance Analysis: Time and Space
Complexity, Asymptotic Notation, Pointer Declaration and Definition, Memory Allocation Functions, Array of
Pointers, Type Definition, Enumerated Types, Accessing Structures, Complex Structures, Arrays of Structures,
Structures and Functions.
2. Linked Lists :
⇒ Representations, Singly, Doubly, Header Node, Circular,
Applications of Linked
Lists: Josephus Problem, Sparse Matrix Storage Using Linked List and Its Operations, Polynomial and Long
Integer Arithmetic.
3. Stacks :
⇒ Representing Stacks in C, Evaluation of Expressions, Multiple Stacks.
4. Applications of Stacks :
⇒ Infix, Postfix and Prefix and their Conversions,
Recursive Definition and Processes,
Recursion in C, Writing Recursive Programs Efficiency of Recursion.
5. Recursion Examples :
⇒ Tower of Hanoi, GCD,
Fibonacci Definition.
6. Queues :
⇒ Linear and Circular Queue, Priority Queue, Linked List Representations.
7. Trees :
⇒ Basic Terminologies, Binary Tree Representation, Binary Search Tree, AVL
Trees, B and B+ Trees.
8. Tree
Operations :
⇒ Inserting, Deleting and Searching.
9. Graph :
⇒ Graph Operations, Spanning Trees, Minimum Cost
Spanning Tree, Shortest Path and Transitive Closure.
10. Searching :
⇒ Binary and Linear Search Algorithms.
11. Sorting :
⇒ Insertion, Quick, Merge, Heap, Radix Sort.
11. Hashing :
⇒ Hashing and Collision Resolution.
1. Introduction :
⇒ Database Systems, RDBMS Definition, Data Models, 3-Schema
Architecture, Challenges
in
Building RDBMS, Different Components of a RDBMS.
2. Relational Data Model :
⇒ Concept of Relations and Its
Characteristics, Schema-Instance, Integrity Constraints, E/R Model, Extended E/R Model, Converting the
Database Specification In E/R and Extended E/R Notation to The Relational Schema.
3. Relational Query Language :
⇒ Relational Algebra, Tuple Relation Calculus, Domain
Relational
Calculus, Introduction to SQL, Data
Definition in SQL, Table and Different Types of Constraints Definitions, Data Manipulation in SQL, Nested
Queries, Notion of Aggregation.
4. Relational Database Design :
⇒ Functional Dependencies and Normal Forms,
Armstrong’s Axioms for FD's, Closure of a Set of FD's, Minimal Covers, Decomposition of Relations to Desired
Normal Forms, Algorithms for 3NF and BCNF Normalization, Multi-Valued Dependencies and 4NF.
5. Transaction
Processing :
⇒ Concepts of Transaction Processing, ACID Properties, Concurrency Control,
Locking Based
Protocols, Recovery and Logging Methods.
6. Data Storage and Indexing :
⇒ File Organizations, Primary, Secondary
Index Structures, Hash-Based Indexing, Dynamic Hashing Techniques, Multi-Level Indexes, B-Tree and B+ Tree.
In school, as a student you might have used Excel to plug in a few number tables or add two cells together. However, Excel is so much more complex than that. For example, did you know that the program can do all of the following:
1. Getting Started With Microsoft Office Excel :
⇒ Topic A: Navigate the Excel User Interface
⇒ Topic B: Use Excel Commands
⇒ Topic C: Create and Save a Basic Workbook
⇒ Topic D: Enter Cell Data
⇒ Topic E: Use Excel Help
2. Performing Calculations :
⇒ Topic A: Create Worksheet Formulas
⇒ Topic B: Insert Functions
⇒ Topic C: Reuse Formulas and Functions
3. Modifying a Worksheet :
⇒ Topic A: Insert, Delete, and Adjust Cells, Columns, and Rows
⇒ Topic B: Search for and Replace Data
⇒ Topic C: Use Proofing and Research Tools
4. Formatting a Worksheet :
⇒ Topic A: Apply Text Formats
⇒ Topic B: Apply Number Formats
⇒ Topic C: Align Cell Contents
⇒ Topic D: Apply Styles and Themes
⇒ Topic E: Apply Basic Conditional Formatting
⇒ Topic F: Create and Use Templates
5. Printing Workbooks :
⇒ Topic A: Preview and Print a Workbook
⇒ Topic B: Set Up the Page Layout
⇒ Topic C: Configure Headers and Footers
6. Managing Workbooks :
⇒ Topic A: Manage Worksheets
⇒ Topic B: Manage Workbook and Worksheet Views
⇒ Topic C: Manage Workbook Properties
1. Working With Functions :
⇒ Topic A:Work with Ranges
⇒ Topic B: Use Specialized Functions
⇒ Topic C: Work with Logical Functions
⇒ Topic D: Work with Date and Time Functions
⇒ Topic E: Work with Text Functions
2. Working With Lists :
⇒ Topic A: Sort Data
⇒ Topic B: Filter Data
⇒ Topic C: Query Data with Database Functions
⇒ Topic D: Outline and Subtotal Data
3. Analyzing Data :
⇒ Topic A: Create and Modify Tables
⇒ Topic B: Apply Intermediate Conditional Formatting
⇒ Topic C: Apply Advanced Conditional Formatting
4. Visualizing Data With Charts :
⇒ Topic A: Create charts
⇒ Topic B: Modify and Format Charts
⇒ Topic C: Use Advanced Chart Features
5. Analyzing Data With PivotTables and PivotCharts :
⇒ Topic A: Create a PivotTable
⇒ Topic B: Analyze PivotTable Data
⇒ Topic C: Present Data with PivotCharts
⇒ Topic D: Filter Data by Using Timelines and Slicers
Investment bankers and accountants aren’t the only ones who rely on Excel; scientists, teachers, business owners, graphic designers, and so many other people turn to the program for help. Regardless of what you do in the office, chances are there’s some way for Excel to be helping you do your job better; it’s just a matter of figuring out what that is.For instance, you can brainstorm those organizational data and create some graphical representations to communicate your ideas.More better, being good at Excel can make you the go-to person in the office; you never know when a colleague of yours needs someone with some Excel to help out, and that person could be you.
1. EXCEL INTRODUCTION :
⇒ Topic A: An overview of the screen, navigation and basic spreadsheet concepts
⇒ Topic B: Various selection techniques
⇒ Topic C: Shortcut Keys
2. CUSTOMIZING EXCEL :
⇒ Topic A: Customizing the Ribbon
⇒ Topic B: Using and Customizing AutoCorrect
⇒ Topic C: Changing Excel’s Default Options
3. USING BASIC FUNCTIONS :
⇒ Topic A: Using Functions – Sum, Average, Max,Min, Count, Counta
⇒ Topic B: Absolute, Mixed and Relative Referencing
4. FORMATTING AND PROOFING :
⇒ Topic A: Formatting Cells with Number formats, Font formats, Alignment, Borders, etc
⇒ Topic B: Basic conditional formatting
5. MATHEMATICAL FUNCTIONS :
⇒ Topic A: SumIf, SumIfs CountIf, CountIfs AverageIf, AverageIfs
6. PROTECTING EXCEL :
⇒ Topic A: File Level Protection
⇒ Topic B: Workbook, Worksheet Protection
7. TEXT FUNCTIONS :
⇒ Topic A: Upper, Lower, Proper
⇒ Topic B: Left, Mid, Right
⇒ Topic C: Trim, Len, Exact
⇒ Topic D: Concatenate
⇒ Topic D: Find,Substitute
8. DATE AND TIME FUNCTIONS :
⇒ Today,Now
⇒ Day,Month,Year
⇒ Date,Date if,DateAdd
⇒ EOMonth,Weekday
9. ADVANCED PASTE SPECIAL TECHNIQUES :
⇒ Paste Formulas, Paste Formats
⇒ Paste Validations
⇒ Transpose Tables
10. Sorting and FILTERING :
⇒ Filtering on Text,Numbers & Colors
⇒ Sorting Options
⇒ Advanced Filters on 15-20 different criteria(s)
11. PRINTING WORKBOOKS :
⇒ Setting Up Print Area
⇒ Customizing Headers and Footers
⇒ Designing the structure of a template
⇒ Print-Titles -Repeat Rows / Columns
12. WHAT IF ANALYSIS :
⇒ Goal Seek
⇒ Scenario Analysis
⇒ Data Tables(PMT Function)
⇒ Solver Tool
13. LOGICAL FUNCTIONS :
⇒ If Function
⇒ How to Fix Errors - iferror
⇒ Nested if
⇒ Complex if and or functions
14. DATA VALIDATION :
⇒ Number,Data & Time Validation
⇒ Text and List Validation
⇒ Custom validations based on formula for a cell
⇒ Dynamic Dropdown List Creation using Data Validation - Dependency List
15. LOOKUP FUNCTIONS :
⇒ Vlookup / HLookup
⇒ Index and Match
⇒ Creating Smooth User Interface Using Lookup
⇒ Nested VLookup
⇒ Reverse Lookup using Choose Function
⇒ Worksheet linking using Indirect
⇒ VLookup with Helper Column
16. PIVOT TABLES :
⇒ Creating Simple Pivot Tables
⇒ Basic and Advanced Value Field Setting
⇒ Classic Pivot table
⇒ Grouping based on numbers and Dates
⇒ Calculated Field & Calculated Items