Programming Courses

WHAT IS COMPUTER PROGRAMMING

Computer programming is the process of creating computer programs.

A program is a set of instructions that tell a computer what to do.

A program is created using a computer language.

A programming language is a language that can be used to communicate with a computer. Therefore, a programming language is the equivalent of a language such as English when it comes to communicating with a computer.

There are several programming languages in existence today, with courses available from GIIM as described below.

Target Audience Includes:

Beginners new to programming/career change
Data scientists & analysts
Software Engineers, Developers
Implementers

These technical training courses are designed to provide hands-on, practical experience. Courses facilitate and encourage active engagement in the respective subject matter. This includes a variety of activities such as labs/experiments, design sprints, observations, reflections, interactive workshops, and prototyping.

Examples of Programing Courses:

Introduction to Programming & C

An introduction to the use of an advanced programming language for use in engineering applications, using C++ as the basic programming language and Microsoft Visual C++ as the program development environment.

Topics covered include basic syntax (data types and structures, input/output instructions, arithmetic instructions, loop constructs, functions, subroutines, etc.) needed to solve basic engineering problems as well as an introduction to advanced topics (use of files, principles of objects and classes, libraries, etc.). Algorithmic thinking for development of computational programs and control programs from mathematical and other representations of the problems will be developed. Basic concepts of computer architectures impacting the understanding of a high-level programming language will be covered.

Introduction to Computer Science and C++

Getting acquainted with C++: data types, input and output, functions, writing simple C++ programs, flow control, Boolean expressions, decision statements, if/then, and switch/case. Loop operations, while, do/while, and for loops. Arrays and pointers. Defining structures and classes, constructors and destructors, and operator overloading using an example String class. Templates. Abstract data types: vectors, lists, stacks, queues, and priority trees with applications. Trees and simple sorting with searching algorithms.

Introduction to Programming and Java

Advanced programming concepts covering classical data structures and object-oriented programming. Emphasis will be on building a collection of re-usable software components that will form the basis of future programming efforts. The data structures covered include lists, stacks, queues, trees, binary search trees, and balanced search trees. The object-oriented features of Java covered include classes, templates, inheritance, polymorphism and run-time binding. Also included is a discussion of the analysis of asymptotic running times of algorithms.

Java Programming

An introduction to the Java programming language for those students who have little or no programming background, through intermediate knowledge of Java. Advanced Java programming topics are also available. Upon completion of this course candidates will be able to read, write and understand essential command-line programs in Java, how to use an Integrated Development Environment (Eclipse) to develop and debug programs, and generate HTML based documentation (Javadoc) for code.

The course is designed to give candidates a well rounded experience in both theoretical and practical aspects of making sophisticated User Interface design decisions. The course is replete with case studies and live projects thereby ensuring that you get a realistic view of the industry.

Basic topics considered will be programs and program structure in general and Java syntax, data types, flow of control, classes, methods and objects, arrays, exception handling, and recursion. In addition, the use of Java in enterprise-wide computing and distributed systems will be introduced by considering APIs in general, and the ones specific to JDBC and the Java security features in particular. Additional topics include:

Java Basics
OOPS Implementation in Java
Array
Interface and Abstract class
String, StringBuffer and StringBuilder
Exception Handling
Collection Framework
Generics
Map API
Java 8 - Stream, Filter
File I/O
Concurrency
Java 8 - Lambda
CSV Reading and Writing
JSON Parsing
JDBC

Python Programming

Python is a high-level, universally useful programming language with a rich syntax that allows software engineers to concentrate more on critical thinking than on syntax errors. There are many reasons to learn python. Such as Web Testing, Data Extraction, Multiple Programming Paradigms, Artificial Intelligence (AI) and Data Science, Cybersecurity, Web Application, and Internet

This course covers everything starting from basics to advanced of Python & MongoDB Concepts. Even Students without basic Python & MongoDB understanding can easily grasp concepts as everything is being taught from basics in a detailed manner.

The Python course will cover topics such as Execution, Variables and Numbers, Strings, Conditionals, Functions, OOPS etc., Upon completion of this course candidates will understand how to use Python the right way, complex functions in python, create/deliver programs with python.

Database considerations will address topics such as RDBMS Vs NoSQL, MongoDB Installation in Windows and Linux, Storage, Aggregation, Backup and Recovery, DB Cloud & Ops Manager Fundamentals etc.

Introduction to Web Programming and Project Development

This course introduces students to the infrastructure underlying the Web, including protocols and markup languages. It also addresses the question of how one presents large volumes of information to people who need to find out what they are looking for quickly. The scope of the course ranges from mechanics to aesthetics. Social and ethical issues are also discussed, including the concept of information ecologies for social acceptance. Networks and protocols; pervasive computing; Web protocols; markup languages and XML; defining information architecture; understanding information needs and information seeking behaviors; organizing Web sites and intranets; navigation systems; search systems; thesauri; from research to design: strategies for information architecture; enterprise information architecture; ethics on the Web; and information ecologies.

Web Programming I

This course will provide students with a first strong approach of internet programming. It will give the basic knowledge on how the Internet works and how to create advanced web sites by the use of script languages, after learning the basics of HTML. The course will teach the students how to create a complex global site through the creation of individual working modules, giving them the skills required in any business such as proper team work and coordination between groups.

Web Programming II

This course focuses on teaching students the newest technologies available in Web Programming. Topics include advanced client side programming, responsive design, NoSQL databases, JQuery, AJAX, Web Site security, and the latest Frameworks. Students will be given the opportunity to suggest topics they would like to discover at the end of the semester. The course is a very hands-on course where everything taught will be practiced through in-class exercises.

Object-Oriented Analysis and Design

Theory of object-oriented design, classes, interfaces, inheritance hierarchy, and correctness; abstract data types, encapsulation, formal specification with preconditions, post conditions and invariants, and proofs of correctness; object-oriented software, objects and classes, genericity, inheritance, polymorphism, and overloading; single and multiple inheritance, programming by contract, sub-classing as subcontract, specification, and verification; programming language examples include C+ +, Java, Smalltalk, and Eiffel.

Introduction to Windows Programming

This course covers programming for the Windows system environment using current Microsoft tools and technologies. The course emphasizes inter-process communication and synchronization techniques as well as explaining advanced memory management, file handling and asynchronous I/O, multi-threaded processes, and techniques applicable to high-performance and large-scale software systems.

Creative Problem Solving and Team Programming

Gives students practice in solving challenging problems by applying algorithmic problem solving techniques learned in prior courses. Students will develop their problem-solving, algorithm-creation, and programming abilities. Problems will be complex and will require invention of an algorithm, not simply straightforward application of standard techniques. Students will work in teams. To provide a focus point and to help make the course fun, students will program their solutions in a style similar to that employed by programming competitions such as the national ACM programming contest. May be repeated for credit.

Systems Programming

Introduction to systems programming in C on UNIX. Students will be introduced to tools for compilation, dynamic linking, debugging, editing, automatic rebuilding, and version control. Some aspects of the UNIX system call interface will be studied, drawn from this list: process creation, signals, terminal I/O, file I/O, inter-process communication, threads, network protocol stacks, programming with sockets, and introduction to RPC. Style issues to be covered include: naming, layout, commenting, portability, design for robustness and debugability, and language pitfalls. UNIX programming and GUI design will be covered, if time allows.

Advanced Programming in the UNIX Environment

In this course, students will learn to develop complex system-level software in the C programming language while gaining an intimate understanding of the UNIX family of operating systems and their programming environment.

Topics covered will include the user/kernel interface, fundamental concepts of UNIX, user authentication, basic and advanced I/O, file systems, signals, process relationships, and interprocess communication. Fundamental concepts of software development and maintenance on UNIX systems (development and debugging tools such as “make” and “gdb”) will also be covered.

Linux, Android, Intuit, SAS, Google Sheets, Excel,

Tableau, & Other Programming Languages

GIIM has access to a large experienced base of faculty who are prepared to meet the specific demands of our clients; hence other programming language programs can be delivered. These courses cover everything starting from basics to advanced programming techniques and administration. Even candidates without a basic programming understanding can easily grasp concepts as everything is being taught from basics in a detailed manner. The courses will cover topics such as Introduction to command shell, File System, Servers, System Monitoring, System backup and recovery etc.

It's easy to write code yet challenging to write good code. Embracing basic programming principles is a surefire way to write high-quality code that is efficient, readable, reliable, secure, and maintainable, regardless of the size of a software project.

Bad code comes in many forms: messy, massive if-else chains, unreliable programs, variables that don't make sense, etc. How do you write effective code? With discipline and purpose. Here are the core programming principles that will make you a better coder.

1. Keep It Simple, Stupid (KISS)

It sounds a little harsh, but it's one of the most important principles to adopt when you’re writing computer code. What does KISS mean?

It means you should be writing code as simple as possible. One of the rules of basic programming is to never get caught up in trying to be overly clever or showing off with a thick block of advanced code. If you can write a script in one line, write it in one line.

Here's a simple function:

function addNumbers(num1, num2) {

return num1 + num2;

}

Pretty simple. It's easy to read, and you know exactly what is going on.

One programming principle in this spirit is to use clear variable names. Take advantage of coding libraries and use existing tools. Make it easy to come back after six months and get right back to work. Keeping things simple will save you so much needless suffering down the line.

2. Write DRY Code

The Don't Repeat Yourself (DRY) computer programming principle means, plainly, not repeating code. It's a common coding mistake. When writing code, avoid duplication of data or logic. If you've ever copied and pasted code within your program, it's not DRY code.

Take a look at this script:

function addNumberSequence(number) {

number = number + 1;

number = number + 2;

number = number + 3;

number = number + 4;

number = number + 5;

return number;

}

Instead of duplicating lines, try to find an algorithm that uses a loop instead.

DRY code is easy to maintain. It's easier to debug one loop that handles 50 repetitions than 50 blocks of code that handle one repetition each.

3. Open/Closed

This principle of programming means that you should aim to make your code open to extension but closed to modification. It ensures that you create code that doesn't need to be modified even when requirements change. This is an important principle when releasing a library or framework that others will use.

For example, suppose you're maintaining a GUI framework. You could release a version for coders to modify and integrate your released code directly. What happens when you release a major update four months later, though?

Their code will break. This will likely make your cohorts very unhappy. They won't want to use your library for much longer, no matter how helpful it may have been in its heyday.

Instead, release code that prevents direct modification and encourages extension. Basic programming principles like this separate core behavior from modified behavior. The code is more stable and easier to maintain.

4. Composition Over Inheritance

If you write code using object-oriented programming, you're going to find this principle of programming to be very useful. The composition over inheritance principle states that objects with complex behaviors should contain instances of objects with individual behaviors. They should not inherit a class and add new behaviors.

Relying on inheritance causes two major issues. First, the inheritance hierarchy can get messy in a hurry. You also have less flexibility in defining special-case behaviors. Let's say you want to implement behaviors to share:

Composition programming is cleaner to write, easier to maintain, and allows for flexibility-defining behaviors. Each individual behavior is its own class. You can create complex behaviors by combining individual behaviors.

5. Single Responsibility

The single responsibility principle states that every class or module in a program should only provide one specific functionality. As Robert C. Martin puts it, "A class should have only one reason to change."

Classes and modules often start off this way. Be careful not to add too many responsibilities as classes get more complicated. Refactor and break them up into smaller classes and modules.

The consequence of overloading classes is twofold. First, it complicates debugging when you're trying to isolate a certain module for troubleshooting. Second, it becomes more difficult to create additional functionality for a specific module. Good programming principles prevent these problems before they become problems to deal with.

6. Separation of C

The separation of concerns concept is an abstract version of the single responsibility principle. This idea states that you should design programs with different parts, and these parts should not have access to each other.

A well-known example of this is the model-view-controller (MVC) design. MVC separates a program into three distinct areas: the data (model), the logic (controller), and what the page displays (view). Variations of MVC are common in today's most popular web frameworks.

For example, the code that handles the database doesn't need to know how to render the data in the browser. The rendering code takes input from the user, but the logic code handles the processing. Each piece of code is completely independent.

The result is code that is easy to debug. If you ever need to rewrite the rendering code, you can do so without worrying about how the data gets saved or the logic gets processed.

7. You Aren't Going to Need It (YAGNI)

This principle means you should never code for functionality on the off chance that you may need something in the future. One of the most important principles of computer programming to learn is that you shouldn't try to solve a problem that doesn't exist.

In an effort to write DRY code, programmers may violate this principle. Often, inexperienced programmers try to write the most abstract and generic code that they can. Too much abstraction, however, causes bloated code that's impossible to maintain.

Only apply DRY programming principles when you need to; if you notice chunks of code written over and over, implement a layer of abstraction. Don't think too far ahead at the expense of your current code batch.

8. Document Your Code

With all of this talk about the principles of coding, it can be easy to forget about the human on the other side who may eventually be getting into your code themselves.

Any senior developer will stress the importance of documenting your code with proper comments. All languages offer them; you should make it a habit to write them. Leave comments to explain objects, enhance variable definitions, and make functions easier to understand.

Here's a JavaScript function with comments guiding you through the code:

// This function will add 5 to the input if odd, or return the number if even

function evenOrOdd(number) {

// Determine if the number is even

if (number % 2 == 0) {

return number;

}

// If the number is odd, this will add 5 and return

else {

return number + 5;

}

Leaving comments is a little more work while you're coding. It takes time and steals your attention away from the real work at hand. You understand your code pretty well anyway, right? Who cares? It's worth remembering that nothing is disposable, even in the world of tech. What is a computer programming principle at the end of the day if the person on the other side ends up getting lost?

We recommend going the extra mile and leaving comments anywhere you worry that things will become murky or unclear, especially when collaborating with others. Don't frustrate your fellow developers by forcing them to decipher your syntax.

Try writing a program, leaving it alone for six months, and returning to modify it. You'll be glad you documented your program instead of having to pour over every function to remember how it works.

9. Refactor

It's hard to accept, but your code isn't going to be perfect the first time. Refactoring code means reviewing your code and looking for ways to optimize it, making it more efficient while keeping the results exactly the same. This is a consideration for writing cleaner and quality code.

Codebases are constantly evolving. One of the principles of programming is remembering that it's completely normal to revisit, rewrite, or even redesign entire chunks of code.

It doesn't mean you didn't succeed the first time you wrote your program; you're inevitably going to get more familiar with a project over time. Use that knowledge to adjust yourself as you make progress.

10. Clean Code at All Costs

Aside from all the fundamental programming principles, leave your ego at the door and forget about writing clever code. When we say this, we mean the kind of code that looks more like a riddle than a solution. You're not coding to impress strangers. You're in this profession to solve problems.

Don't try to pack a ton of logic into one line. Leave clear instructions in your comments and documentation. If your code is easy to read, it will also usually be easy to maintain.

Good programmers and readable code go hand-in-hand. Leave comments when necessary, adhere to style guides, and put yourself in the next guy's shoes whenever possible.

Learn the Principles of Computer Programming to Be a Good Programmer from the breadth of GIIM programs

Learning how to be a good programmer takes quite a bit of time and effort. These rules of basic programming are a roadmap to becoming a professional programmer. By following these time-honored principles, you’ll set yourself up for success in your future programming career.

What we do
Button
Button
Button
Button