Coding / Programming Career Path Courses:

Learning to program is both fun and easy by taking this brand new and exciting Introduction to Programming for Non-Programmers course! Not only will you learn the foundations of how to program, but you’ll also gain a solid foundation in the world’s most popular computer language: JavaScript.  Without having to install any special software, and using only your web browser and your text editor, you’ll journey into the exacting world of programming. Using an easy to learn training style, you’ll learn about the JavaScript language, functions, variables, making decisions, looping, and more. At the end of the course, you’ll be in a great position to take other introductory programming language course.

View all course details Enroll Now
Video Title
Length
01: Introduction to Programming
16 min
02: Introduction to JavaScript
15 min
Quiz: Introduction to Programming and JavaScript
04: Functions Part 2
17 min
Quiz: Functions
05: Variables
24 min
Quiz: Variables
06: Making Decisions
22 min
Quiz: Making Decisions
07: Repeating Steps
24 min
Quiz: Repeating Steps
08: Course Summary
20 min
09: Capstone Exercise
15 min
Course Survey
View all course details
Module 00: Course Introduction
 
Module 01: Introduction to Programming
  • What is a computer language?
  • Why should you learn a computer language?
  • What computer language should you learn first?
  • Demo: Let's Make our First Statement in JavaScript!
  • Lab Exercise: hello.html
Module 02: Introduction to JavaScript 
  • JavaScript Advantages
  • Web Browser and JavaScript
  • .html File Extension
  • Editing hello.html
  • // and /* … */
  • Demo: Hello World
  • Lab Exercise: Hello World
Module 03: Functions Part 1  
  • About Functions
  • alert() w/o input parameter
  • Semicolon
  • alert() w/Input parameter
  • Strings
Module 04: Functions Part 2 
  • Defining Functions without inputs
  • Defining Functions with inputs
  • Returning values from Functions
  • Demo: Using the Alert Function
  • Lab Exercise: Using the Alert Function
Module 05: Variables 
  • JavaScript Variables
  • var keyword
  • String variables
  • Number variables
  • Operators: +, -, *, /
  • Confirm Function
  • true, false
  • prompt() Function
  • Demo: Using Variables
  • Lab Exercise: Using Variables
Module 06: Making Decisions 
  • if statement
  • if else statement
  • confirm() with if statement
  • confirm() with if-else statement
  • Compare Operators: ==, <. >, <=, >=
  • if-else-if…
  • Demo: Making Decisions
  • Lab Exercise: Making Decisions
Module 07: Repeating Steps 
  • Repeating fixed number of times
  • Repeating variable number of times
  • while statement
  • while statement with prompt()
  • Checking for null
  • Demo: Repeating Steps
  • Lab Exercise: Repeating Steps 
Module 08: Course Summary
  • Put All Skills Together To Write a Javascript App
  • Review the key concepts
  • Write a temperature conversion script!

 

View all course details

The only prerequisite is a basic familiarity with computers, along with an eagerness to learn programming. You do not need any programming experience.

View all course details

As an overview, this course touches on all of the functions within an operating system and the interrelationships between those functions. This course can be used stand-alone to gain a basic understanding of all of the concepts presented. In addition, it has been designed to follow a companion textbook, Modern Operating Systems by Andrew S. Tanenbaum, for those interested in deeper exploration of the concepts. The companion textbook may be used along with viewing this course or as a resource for later reference when more detailed information is needed.

View all course details Enroll Now
Video Title
Length
01: Introduction to Operating Systems
25 min
02: Operating Systems and Hardware
25 min
03: Operating System Concepts
26 min
04: Operating System Structure
22 min
05: Processes and Threads
24 min
06: Interprocess Communication
22 min
08: Deadlocks
23 min
09: Memory Management
28 min
10: Input/Output
27 min
11: Files Systems
25 min
12: Multimedia Operating Systems
25 min
13: Multiple Processor Systems
27 min
14: Operating System Security
25 min
15: Examples of Operating System Architectures
24 min
16: Course Summary
6 min
Course Survey
View all course details
Module 00: Course Introduction - Fundamentals of Operating Systems
 
Module 01:  Introduction to Operating Systems
  • What is an operating system?
  • History of Operating Systems
  • Types of Operating Systems
Module 02: Operating Systems and Hardware
  • Operating Systems Concepts
  • Processor and Processor Features
  • Processor Pipeline and Execution
  • Operating Systems and Processors
  • Memory Overview
  • I/O Devices Overview
  • Operating Systems and Hardware Quiz
Module 03: Operating System Concepts
  • Types of Operating Systems
  • Services Provided by Operating Systems
  • Invoking Operating System Services
  • Operating System Concepts Quiz
Module 04: Operating System Structure
  • Monolithic Systems
  • Layered Systems
  • Virtual Machines
  • Other Structures 
  • Operating System Structure Quiz
Module 05: Processes and Threads
  • The Process Model
  • The Thread Model
  • Implementation Techniques
  • Trade-offs 
  • Processes and Threads Quiz
Module 06:  Interprocess Communication 
  • Types of Interprocess Communication
  • Operating System Implementations
  • Add-on Implementations
  • Interprocess Communication Quiz
Module 07:  Scheduling
  • Introduction to Operating System Scheduling
  • Types of Schedulers
  • Policy Versus Mechanism
  • Thread Scheduling
  • Scheduling Quiz
Module 08:  Deadlocks
  • What are deadlocks?
  • Detection and Recovery
  • Avoidance
  • Prevention
  • Other Issues 
  • Deadlocks Quiz
Module 09:  Memory Management
  • Basics of Memory Management
  • Swapping
  • Paging for Memory Management
  • Paging for Virtual Memory
  • Implementation Issues 
  • Memory Management Quiz
Module 10:  Input/Output
  • Principles of I/O Hardware
  • Principles of I/O Software
  • I/O Software Layers
  • Types of I/O Devices
  • Power Management
  • Input/Output Quiz
Module 11:  Files Systems
  • File Systems Basics 
  • Files
  • Directories
  • Implementation
  • Examples 
  • File Systems Quiz
Module 12:  Multimedia Operating Systems
  • Introduction to Multimedia Operating Systems
  • Multimedia Files
  • Multimedia Process Scheduling
  • Multimedia File Systems
  • Caching
  • Disk Scheduling
  • Multimedia Operating Systems Quiz
Module 13:  Multiple Processor Systems
  • Types of Multiple Processors
  • Multiple Processor Hardware  
  • Multiple Processor Operating Systems
  • Multiple Processor Scheduling
  • Multiple Computers
  • Multiple Processor Systems Quiz 
Module 14:  Operating System Security
  • The Security Environment
  • Basics of Cryptography
  • User Authentication 
  • Security Attacks 
  • Protection Mechanisms
  • Security Quiz
Module 15: Examples of Operating System Architectures
  • Unix and Linux
  • Windows 
  • Others
  • Operating System Architectures Quiz
Module 16: Course Summary
View all course details

Course attendees should have a general understanding of computer use, including starting and using applications, creating and using files, and a basic exposure to using computers connected to some form of network. Some knowledge of programming, computer hardware and application design will be helpful but is not required.  If you do not have this experience, we recommend the following GogoTraining course, Introduction to Programming and Coding for Everyone with JavaScript.

View all course details

This C Programming Bootcamp Part 1 online course, part 1 of a two part series will introduce you to the C programming language.  You will start with the layout of a C program and venture into control statements, loops, and functions. When you complete this course, you will have the skills to be an effective and productive C Programmer. 

View all course details Enroll Now
Video Title
Length
01: What is C?
25 min
Quiz: What is C?
02: A Simple C Program
20 min
Quiz: A Simple C Program
03: A Few More Basics
25 min
Quiz: A Few More Basics
Quiz: Variables
05: DataTypes
15 min
Quiz: DataTypes
06: Arithmetic Operations Part 1
22 min
Quiz: Arithmetic Operations Part 1
07: Arithmetic Operations Part 2
21 min
Quiz: Arithmetic Operations Part 2
08: Lab Exercise Solution: Arithmetic Operations
10 min
09: If Statements Part 1
23 min
Quiz: If Statements Part 1
10: If Statements Part 2
32 min
Quiz: If Statements Part 2
11: Lab Exercise Solution: If Statements
9 min
12: Conditional Expressions and Macros
25 min
Quiz: Conditional Expressions and Macros
13: Switch Statements
23 min
Quiz: Switch Statements
14: Loops
26 min
Quiz: Loops
15: Lab Exercise Solution: Loops
7 min
16: Functions
29 min
Quiz: Functions
17: Lab Exercise Solution: Functions
20 min
Course Survey
View all course details
Module 00: Course Introduction - C Programming Bootcamp Part 1 Online Course
 
Module 01: What is C?
  • History of C
  • Purpose of the Language
  • Basic Features of C
Module 02: A Simple C Program
  • Layout
  • Declarations
  • Body
  • Demo: A Simple C Program
Module 03: A Few More Basics
  • A Quick Look at printf
  • Demo: printf
Module 04: Variables 
  • Characters
  • Integers
  • Floating Point Numbers
  • Naming Variables
  • Variables Quiz
Module 05: DataTypes
  • Basic DataTypes
  • Constants
  • Enumeration
  • DataTypes Quiz
Module 06: Arithmetic Operations Part 1
  • Addition and Subtraction
  • Multiplication and Division
  • Modulus
  • Integer vs. Floating Point Arithmetic
  • Precedence
  • Assignment Operators
Module 07: Arithmetic Operations Part 2
  • Increment Operators
  • Decrement Operators
  • Lab Exercise: Arithmetic Operations
Module 08: Lab Exercise Solution: Arithmetic Operations
 
Module 09: If Statements Part 1
  • if and if-else Statements
  • Relational, Logical and Equality Operators
  • The ! Operator
  • Value of an Expression
Module 10: If Statements Part 2
  • Hazards
  • Using getchar and Checking the Results
  • Demo: getchar
  • Lab Exercise: if Statements
Module 11: Lab Exercise Solution: If Statements
 
Module 12: Conditional Expressions and Macros
  • Conditional Expressions
  • Lab Exercise: Conditional Expressions
  • Lab Exercise Solution: Conditional Expressions
  • Macros
Module 13: Switch Statements
  • Switch Statements
  • Lab Exercise: Switch Statements
  • Lab Exercise Solution: Switch Statements
Module 14: Loops
  • For Loops
  • While Loops
  • Do-While Loops
  • Lab Exercise: Loops
Module 15: Lab Exercise Solution: Loops
 
Module 16: Functions
  • Declaring Functions
  • Returning Values
  • Variables and Scope
  • Understanding the Stack
  • Lab Exercise: Functions
Module 17: Lab Exercise Solution: Functions
View all course details

Students should have experience with a programming language or have taken GogoTraining's Introduction to Programming for Non-Programmers or Introduction to Programming and Coding for Everyone with JavaScript.  While the syntax of the C language is covered thoroughly in this course, there is an assumption of knowledge and skill with the operating system you will be utilizing, and an underlying knowledge of programming basics.

View all course details

This C Programming Bootcamp Part 2 online course, part 2 of a two part series, will introduce you to the C programming language.  You will start basic I/O and move into more complex data types such as arrays, structures, and pointers using solid programming techniques.  When you complete this course, you will have the skills to be an effective and productive C Programmer. 

View all course details Enroll Now
Video Title
Length
01: Introduction to I/O
13 min
02: Basic Output
16 min
03: Basic Input
32 min
04: Things to Watch Out For in I/O
18 min
05: A Look at Pointers
29 min
06: Using Pointers
18 min
07: Arrays
33 min
08: Advanced Arrays
25 min
09: Structures
35 min
10: Structure Pointers
18 min
11: Arrays of Structures
22 min
12: Advanced Structures
29 min
13: Lab Exercise: Advanced Structures
3 min
15: Character Strings
28 min
16: Multidimensional Arrays
29 min
17: Variables, Types and Scope
16 min
18: More on Variables, Types and Scope
25 min
19: Lab Exercise Solution: More on Variables, Types and Scope
17 min
Course Survey
View all course details

Module 00: Course Introduction - C Programming Bootcamp Part 2 Online Course

Module 01: Introduction to I/O

  • Standard in/out
  • Redirection
  • Demo: Redirection

Module 02: Basic Output

  • Controlling the Output with printf
  • Format Codes
  • Lab Exercise: printf
  • Lab Exercise Solution: printf

Module 03: Basic Input

  • Using scanf
  • & Operator
  • Understanding Memory
  • Demo: scanf

Module 04: Things to Watch Out For in I/O

  • I/O Hazards
  • Lab Exercise: scanf
  • Lab Exercise Solution: scanf
  • Challenge Yourself: I/O Independent Exercise

Module 05: A Look at Pointers

  • Understanding Pointers
  • Declaring and Dereferencing
  • Pointers and Functions

Module 06: Using Pointers

  • Legal Pointer Operations
  • Hazards
  • Lab Exercise: Pointers
  • Lab Exercise Solution: Pointers

Module 07: Arrays

  • Declaring and Initializing Arrays
  • Utilizing Arrays
  • Arrays as a Function Parameter

Module 08: Advanced Arrays

  • Using Pointers to Arrays
  • Lab Exercise: Arrays
  • Lab Exercise Solution: Arrays

Module 09: Structures

  • Declaring Structures
  • Initializing Structures
  • Structures as Parameters
  • Lab Exercise: Structures
  • Lab Exercise Solution: Structures

Module 10: Structure Pointers

  • Pointers to Structures
  • Structure Pointer Parameters
  • -> Operator

Module 11: Arrays of Structures 

  • Introduction to Arrays of Structures
  • Initializing Structure Arrays
  • Pointers to Arrays of Structures
  • Hazards
  • Lab Exercise: Array of Structures
  • Lab Exercise Solution: Array of Structures

Module 12: Advanced Structures

  • Structures Members
  • Structures in a Structure
  • Math Library

Module 13: Lab Exercise: Advanced Structures

  • Lab Exercise: Math and Structures
  • Lab Exercise Solutions: Math and Structures

Module 14: Character Arrays 

  • Character Arrays
  • Initializing Character Arrays
  • Printing Character Arrays

Module 15: Character Strings

  • Character Strings
  • String Constants
  • Lab Exercise: Character Strings
  • Lab Exercise Solution: Character Strings

Module 16: Multidimensional Arrays

  • Declaration and Initialization
  • Utilizing Multidimensional Arrays
  • Pointers and the Multidimensional Array
  • Lab Exercise: Matrix
  • Lab Exercise Solution: Matrix

Module 17: Variables, Types and Scope

  • Automatic Variables
  • Static variables
  • Registers

Module 18: More on Variables, Types and Scope

  • Local and Global Scope
  • Private Scope
  • Lab Exercise: Variables, Types and Scope

Module 19: Lab Exercise Solution: More on Variables, Types and Scope

View all course details

Students should have experience with a programming language or have taken GogoTraining's Introduction to Programming for Non-Programmers or Introduction to Programming and Coding for Everyone with JavaScript, and C Programming Bootcamp Part 1.  While the syntax of the C language is covered thoroughly in this course, there is an assumption of knowledge and skill with the operating system you will be utilizing, and an underlying knowledge of programming basics.

View all course details
In Java SE 8 Programming Part 1 you will begin programming in Java right from the start.  You will learn the critical parts of the Java language and program with them immediately to reinforce every concept that you learn.  This course covers key Java features including data types, variables, classes, methods, objects, inheritance, polymorphism, decision making, loops, strings, arrays and more. You will get a deep dive into Java programming so you can start programming in Java right away. From Java SE 8 Programming Part 1 you will go on to Java SE 8 Programming Part 2, which will enable you to create fully functional programs in Java and call yourself an Object-Oriented Programmer. This two-part series will also help prepare you to take Oracle’s Java SE 8 Programmer 1 Certification exam.
 
The Java 8 SE8 online video course is taught by Donna Martin a programming expert with over 25 years of experience programming with Linux systems programming, C, GTK+, X, TCL, FORTRAN, COBOL, Shell Scripting, Assembler, web programming and Java.  She currently works as an Analyst at a major hospital and teaches programming to students of all ages.  Donna makes concepts easy to learn and gives you the skills and knowledge you need to start programming in Java right away.
 
Did you know that learning to code will make you more skilled than 95% of the work force and that Java is one of the top programming languages in the world today?  Businesses of all sizes are powered by applications written in Java as are Android Apps.  If you have an idea for an innovative type of business software or an Android App then Java is the language for you.  For example, Angry Birds, Temple Run and Candy Crush Saga are all written in Java. Because Java is such a widely used language, companies like eBay, JP Morgan, Google and many, many, more all hire Java programmers. 
View all course details Enroll Now
Video Title
Length
01: Jump into a Java Program
14 min
02: Running a Java Program
16 min
03: Lab Exercise: Create Your Own First Program
14 min
04: Basic Data Types and Variables
23 min
05: Operators
26 min
06: Lab Exercise: Basic Calculations
5 min
07: Strings
13 min
08: Making a Decision: if Statements
17 min
09: Lab Exercise: Using if statements
8 min
10: Decisions, decisions
17 min
11: Lab Exercise: Using switch statements
13 min
12: Classes
14 min
13: More on Strings
15 min
14: Lab Exercise: Using Strings
15 min
15: Methods
18 min
16: Implementing Your Own Class
19 min
17: Lab Exercise: Declaring and Using Classes
11 min
18: Loops
20 min
19: More on Loops
22 min
20: Lab Exercise: Implementing Loops
5 min
21: Arrays
17 min
22: More on Arrays
19 min
23: Lab Exercise: Implementing Arrays
19 min
24: More on Methods
16 min
25: Classes and Methods: Take 3
24 min
26: Lab Exercise: Overloading Methods
9 min
27: Strings Take 3
13 min
28: Lab Exercise: String Comparisons
9 min
30: Lab Exercise: Implementing Enumerated Types
5 min
Quiz: Java SE 8 Programming Part 1
View all course details
Module 00: Course Introduction – Java SE 8 Programming Part 1
 
Module 01: Jump into a Java Program 
  • A  Working Piece of Code
  • Looking at:
         o  Syntax
         o  Compile and run
         o  What is OOP
         o  Methods, Classes
 
Module 02: Running a Java Program
  • The Java Compiler
  • Understanding ByteCode
  • The Java Virtual Machine
Module 03: Lab Exercise: Create Your Own First Program
 
Module 04: Basic Data Types and Variables 
  • int, float, boolean, char
  • Intro to Variables
  • Declaring & Initializing Variables
Module 05: Operators
  • +, -, *, /, %
  • ++, --
  • Assignments
  • Precedence of Operations
  • Type Conversion and Casting
Module 06: Lab Exercise: Basic Calculations
 
Module 07: Strings
  • String Variables
  • String Concatenation
  • Strings and Memory
Module 08: Making a Decision: if Statements
  • if Statements  
  • Comparison and Boolean Operators
  • else and elseif
Module 09: Lab Exercise: Using if statements 
 
Module 10: Decisions, decisions
  • switch statements
  • break statements for the switch statement
  • Strings and the switch statement
Module 11: Lab Exercise: Using switch statements
 
Module 12: Classes
  • What is a Class?
  • Declaring Classes
  • Fields & Constructors
Module 13: More on Strings
  • StringBuilder
  • StringObjects
  • StringMethods
Module 14: Lab Exercise: Using Strings
 
Module 15: Methods
  • Declaring Methods
  • Parameters and Return Types
  • Calling (Invoking) Methods
Module 16: Implementing Your Own Class
  • Declaring Fields
  • Constructors
  • Class vs. Instance Methods
Module 17: Lab Exercise: Declaring and Using Classes
 
Module 18: Loops
  • while 
  • do-while
  • for 
Module 19: More on Loops
  • More on the for
  • Hazards
  • break and continue
Module 20: Lab Exercise: Implementing Loops
 
Module 21: Arrays
  • Declaring Arrays
  • Initializing arrays
  • The length operator
Module 22: More on Arrays
  • Array Bounds
  • The enhanced-for
  • Array Methods
Module 23: Lab Exercise: Implementing Arrays
 
Module 24: More on Methods
  • Understanding how arguments are passed to methods
  • Call by Value vs. Call by Reference
  • Arrays as Parameters
Module 25: Classes and Methods: Take 3
  • Static Variables
  • The this keyword
  • Overloading a Method
Module 26: Lab Exercise: Overloading Methods
 
Module 27: Strings Take 3
  • Strings and Comparisons
  • References vs. Values
  • System.out.print()
Module 28: Lab Exercise: String Comparisons
 
Module 29: Enumerated Types
  • Declaring Enumerated Types
  • Comparing enums
  • enums and switch statements
Module 30: Lab Exercise: Implementing Enumerated Types

 

View all course details
In Part 2 of Java SE 8 Programming you will program right from the start.  Part 2 delves into more advanced Java 8 features including garbage collection, nested types, packages, APIs, advanced data types (lists, sets, maps, two-dimensional arrays), handling events, using a database, exceptions and more. 
 
This course also covers new Java 8 features including lambda expressions, streams, and the new date and time API.  You will also take a deeper dive into object-oriented programming.  When you finish this two-part Java SE 8 series, you will be able to create fully functional programs in Java and will be able to call yourself an Object-Oriented Programmer. This two-part series will also fully prepare you to successfully take the Oracle’s Java SE 8 Programmer 1 Certification exam.
 
The Java SE 8 Programming online video series is taught by Donna Martin a programming expert with over 25 years of experience programming with Linux systems programming, C, GTK+, X, TCL, FORTRAN, COBOL, Shell Scripting, assembler, web programming and Java.  She currently works as an Analyst at a major hospital and teaches programming to students of all ages.  Donna makes concepts easy to learn and gives you the skills and knowledge you need to start programming in Java right away.
 
Learning to code with Java will give you the skillset of one of the most in-demand languages.  Businesses of all sizes are powered by applications written in Java as are Android Apps.  If you have an idea for an innovative type of business software or an Android App, then Java is the language for you.  For example, Angry Birds, Temple Run and Candy Crush Saga are all written in Java.  Because Java is such a widely used language, companies like eBay, JP Morgan and Google all hire Java programmers.
View all course details Enroll Now
Video Title
Length
01: OOPs revisited
13 min
02: Encapsulation
18 min
03: Lab Exercise: Using Encapulation
18 min
04: Inheritance
24 min
05: More on Inheritance
20 min
06: Lab Exercise: Creating an Inheritance Relationship
5 min
07: Packages
9 min
08: Lab Exercise: Using java.lang.Math
5 min
09: The Math Package
22 min
10: The System Class
14 min
11: Lab Exercise: Using BigDecimal and Formatted Output
17 min
13: Lab Exercise: Asking Questions, Getting Answers
14 min
14: Exceptions
17 min
15: Lab Exercise: Implementing Exception Handling
7 min
16: Command Line Arguments
8 min
17: Lab Exercise: Parsing the Command Line
6 min
18: Primitive Wrapper Classes
19 min
19: Lab Exercise: Using Primitive Wrapper Classes
17 min
20: Abstraction
17 min
21: Lab Exercise: Implementing Abstraction
10 min
22: Polymorphism
22 min
23: A Few More Things
19 min
24: Lab Exercise: An Exercise in Polymorphism
23 min
25: Interfaces in Java 8
26 min
26: Lab Exercise: Implementing an Interface
15 min
27: More on Interfaces in Java 8 (Functional Interfaces & Lambda Expressions)
24 min
28: Lab Exercise: Writing your own Lambda expression
17 min
29: Two-Dimensional Arrays
23 min
30: Lab Exercise: Using Two-Dimensional Arrays
9 min
31: ArrayLists
27 min
32: Lab Exercise: Implementing ArrayLists
15 min
33: Handling Dates in Java 8
26 min
34: Handling Time in Java 8
22 min
35: Lab Exercise: Using java.time
5 min
36: Rolling Together
8 min
37: Where Do You Go from Here?
2 min
38: The Java SE 8 Quiz
4 min
Quiz: Java SE 8 Test Prep Quiz
View all course details
Module 00: Course Introduction – Java SE 8 Programming Part 2
 
Module 01: OOPs revisited 
  • Classes
  • Inheiritance
  • Interfaces
  • Packages
Module 02: Encapsulation  
  • What is encapsulation?
  • Access Control 
  • Access Methods
Module 03: Lab Exercise: Using Encapulation 
 
Module 04: Inheritance
  • Basic Inheritance
  • Subclasses and Superclasses
  • Extending a Class
Module 05: More on Inheritance
  • Overriding Methods
  • super Methods
  • protected Access
Module 06: Lab Exercise: Creating an Inheritance Relationship
 
Module 07: Packages 
  • What are packages?
  • Accessing packages
  • java.lang
Module 08: Lab Exercise: Using java.lang.Math  
 
Module 09: The Math Package 
  • Math in Java
  • Using BigDecimal
  • RoundingMode
Module 10: The System Class
  • System.out
  • Formatted output
  • in, out and err
Module 11: Lab Exercise: Using BigDecimal and Formatted Output
 
Module 12: Input  
  • How to Ask for Information From Users
  • Scanner
  • The next methods
  • Delimeters
Module 13: Lab Exercise: Asking Questions, Getting Answers
 
Module 14: Exceptions
  • What are Exceptions?
  • Types of exceptions
  • try, catch and finally
Module 15: Lab Exercise: Implementing Exception Handling
 
Module 16: Command Line Arguments
  • Using args
  • Number of arguments
  • Command line separators

Module 17: Lab Exercise: Parsing the Command Line

Module 18: Primitive Wrapper Classes
  • Primitives vs Objects
  • Primitive Wrapper Fields
  • The parse methods
Module 19: Lab Exercise: Using Primitive Wrapper Classes
 
Module 20: Abstraction
  • Abstract classes
  • Abstract methods
  • Resolving an abstraction
Module 21: Lab Exercise: Implementing Abstraction
 
Module 22: Polymorphism
  • What is the big word, Polymorphism?
  • Upcasting
  • Downcasting
Module 23: A Few More Things
  • More on casting
  • instanceof
  • toString
Module 24: Lab Exercise: An Exercise in Polymorphism
 
Module 25: Interfaces in Java 8
  • Defining a Java Interface
  • Interface Fields and Methods
  • Override Annotation
Module 26: Lab Exercise: Implementing an Interface
 
Module 27: More on Interfaces in Java 8 (Functional Interfaces & Lambda Expressions)
  • Functional interfaces
  • Anonymous Classes
  • Lambda expressions
Module 28: Lab Exercise: Writing your own Lambda expression
 
Module 29: Two-Dimensional Arrays
  • Declaring Two-Dimensional Arrays
  • Initializing
  • Determining the Length of Rows and Columns
  • Two-dimensional Arrays and Methods
Module 30: Lab Exercise: Using Two-Dimensional Arrays
 
Module 31: ArrayLists
  • ArrayLists vs Arrays
  • Creating an ArrayList
  • ArrayList Methods
  • Size of an ArrayList
Module 32: Lab Exercise: Implementing ArrayLists
 
Module 33: Handling Dates in Java 8
  • java.time
  • Handling Local Dates and Time
  • Formatting Dates and Times
  • Working with Periods
Module 34: Handling Time in Java 8
  • LocalTime
  • Time Zones
  • LocalDateTime
  • Formatting
Module 35: Lab Exercise: Using java.time
 
Module 36: Rolling Together
  • Lab Exercises
Module 37: Where Do You Go from Here?
  • Curriculum Path
  • Job Path and Roles

Module 38: The Java SE 8 Quiz

View all course details
This Python 3 Programming Essentials online training course will teach you the basics of Python, a powerful programming language used to solve many different types of problems. You will start by learning the basics of Python, and by the end of this course, students will be able to write Python programs to processes, text, work with complex data types, handle exceptions, and begin designing object-oriented programs. This course is updated for any version of Python 3.x.
 
Once you have completed Python 3 Programming Essentials the next course in this series is Advanced Python 3 Programming. The Advanced Python Programming course will enhance your Python knowledge by discussing complex data types, object oriented programming, GUI programs, regular expressions, threads, network programming, using SQL, and extending Python with C. Click here to learn more about Advanced Python 3 Programming.
 
Python is a general purpose language that was released in the 1990’s.  It is designed to be highly readable and that makes it very easy for beginners. Even though the learning curve is shorter than many other languages, it allows you to do scientific computing, web development and 3d rendering.  Python had a major role in starting YouTube, Instagram and Reddit.  Because Python is useful in many different applications there are jobs available in just about every market. Companies like Google and YouTube have requirements for Python Programmers most all the time.
View all course details Enroll Now
Video Title
Length
01: Introduction to Python
21 min
02: Numbers Part 1
19 min
03: Numbers Part 2
13 min
04: Strings
25 min
06: List Methods
17 min
07: Control Flow Constructs Part 1
14 min
08: Control Flow Constructs Part 2
12 min
09: Tuples
14 min
10: Dictionaries
11 min
11: Dictionary Methods
14 min
12: The File Type Part 1
13 min
13: The File Type Part 2
11 min
14: Functions Part 1
11 min
15: Functions Part 2
11 min
16: Complex Data Types Part 1
13 min
17: Complex Data Types Part 2
8 min
18: Introduction to Modules
11 min
19: Introduction to Object Oriented Python
15 min
20: Object Oriented: Inheritance
10 min
21: Introduction to Exception Handling
16 min
22: Using the sys Module
9 min
23: Using the os Module Part 1
10 min
24: Using the os Module Part 2
14 min
25: Moving from Python 2 to Python 3
19 min
Course Survey
View all course details

Module 00: Learn Python Programming - Course Introduction

Module 01: Introduction to Python

  • Python Websites and Books
  • A Little History
  • Interactive Python and Python Programs
  • Lab: Intro to Python
  • Demo: Programs, Variables, Syntax

Module 02: Numbers Part 1

  • Numeric Literals, Variables and Operators
  • Reading from Standard Input
  • Demo: Standard Input, if statement, while statement

Module 03: Numbers Part 2

  • if and while statements
  • Logical Operators
  • Lab: Numbers, if and while

Module 04: Strings

  • String Literals, Variables and Operators
  • Strings as Sequences and Slicing
  • String Formatting
  • String Methods
  • Lab: Strings

Module 05: Lists

  • Lists Defined
  • Creating, Indexing, Slicing Lists
  • Looping through Lists
  • List Operators
  • Lab: Lists
  • Demo: Looping

Module 06: List Methods

  • Creating Lists with split()
  • Joining Lists with join()
  • List Methods including append(), count() and pop()
  • Lab: Using List Methods
  • Demo: Using Lists

Module 07: Control Flow Constructs Part 1

  • if, if/else
  • while Loop
  • break and continue
  • Lab: More on if and while

Module 08: Control Flow Constructs Part 2

  • for Statements
  • The Range Method
  • for Loop
  • List Comprehensions
  • Lab: Using Looping Constructs
  • Demo: Various statements

Module 09: Tuples

  • Tuples Defined
  • Creating, Indexing, Slicing Tuples
  • Tuple Comprehensions
  • Tuple Operators
  • Lab: Working with Tuples
  • Demo: Creating Tuples

Module 10: Dictionaries

  • Dictionaries Defined
  • Creating and Indexing Dictionaries
  • Processing Dictionaries
  • Demo: Creating Dictionaries

Module 11: Dictionary Methods

  • Keys Method
  • Value Method
  • Creating Dictionaries as a Flexible List
  • Lab: Working with Dictionaries
  • Demo: Working with Dictionaries

Module 12: The File Type Part 1

  • The File Type Defined
  • Opening and Closing Files
  • Reading From and Writing to Files
  • Demo: File Parts

Module 13: The File Type Part 2

  • File iIterators
  • sys.stdin
  • Files and List Comprehensions
  • Lab: File Type
  • Demo: Working with Files

Module 14: Functions Part 1

  • Functions Definition and Invocation
  • Return Values and Function Arguments
  • Arguments Passed by Reference
  • Demo: Values and Arguments

Module 15: Functions Part 2

  • Default Arguments
  • Calling Functions with Keywords
  • Global Variables with Global
  • Lab: Writing Functions
  • Demo: Variables

Module 16: Complex Data Types Part 1

  • Introduction to the Basic Complex Data Types
  • List of Lists
  • Processing a List of Lists
  • Lab: Working with a List of Lists
  • Demo: Lists of Lists

Module 17: Complex Data Types Part 2

  • Dictionary of Dictionaries
  • Processing a Dictionary of Dictionaries
  • Arbitrarily Nested Data Types
  • Lab: Working with a Dictionary of Dictionaries
  • Demo: Dictionary of Dictionaries

Module 18: Introduction to Modules

  • Modules Defined
  • Standard Library
  • Location of Library Files
  • The from Statement
  • Lab: Creating and Using a Module
  • Demo: Modules and Libraries

Module 19: Introduction to Object Oriented Python

  • Object Oriented Programming Defined
  • Creating a Class
  • Constructors
  • Lab: Creating and Using a Class
  • Demo: Classes

Module 20: Object Oriented: Inheritance

  • Introduction to inheritance
  • A Derived Class Constructor
  • Using a Derived Class
  • Brief Discussion of Advanced Topics
  • Lab: Implementing Inheritance
  • Demo:Inheritance

Module 21: Introduction to Exception Handling

  • Built-in exceptions
  • Handling exceptions with the try / except statement
  • Handling KEY ERROR exceptions
  • Lab: An Exceptional Lab
  • Demo:Exceptions and Statements

Module 22: Using the sys Module

  • Command Line Arguments
  • Exiting the Program
  • Various sys Properties
  • Demo: Command lines and Exiting

Module 23: Using the os Module Part 1

  • Environment Variables
  • Changing Directories, File Permissions
  • Making and Removing Directories
  • Deleting Files
  • Demo: Environment and the os

Module 24: Using the os Module Part 2

  • Executing External Programs
  • Opening Pipes
  • Advanced Topics
  • Lab: Using the sys and os Modules
  • Demo: Pipes and Executing External Programs
Module 25: Moving from Python 2 to Python 3
  • Common gotchas
  • Syntax changes
  • String formatting
  • Changes to exceptions
  • Miscellaneous stuff
  • Porting from Python 2.x to Python 3.x
View all course details

You need to have experience in a high-level programming language (for example: C, C++, Java, Perl, etc.) and be able to perform basic operations in the operating systems. If you do not have this experience, we recommend you select from the following GogoTraining courses:

View all course details
This Advanced Python 3 Programming online training course picks up where Python Essentials left off.  In this course you will enhance your Python knowledge by discussing complex data types, object oriented programming, GUI programs, regular expressions, threads, network programming, using SQL, and extending Python with C. This course has been updated for any version of Python 3.x.
 
In order to take this course you need to have taken Python 3 Programming Essentials or have equivalent experience in the concepts taught in that course.
 
Python is a general purpose language that was released in the 1990’s.  It is designed to be highly readable and that makes it very easy for beginners. The learning curve is shorter than many other languages, it allows you to do scientific computing, web development and 3d rendering.  Python had a major role in starting YouTube, Instagram and Reddit.  Because Python is useful in many different applications there are jobs available in just about every market. Companies like Google and YouTube have requirements for Python Programmers most all the time.
View all course details Enroll Now
Video Title
Length
01: Miscellaneous Tidbits
20 min
02: Complex Data Types Part 1
19 min
03: Complex Data Types Part 2
11 min
05: Object Oriented Review
22 min
06: More Object-Oriented Topics
19 min
07: Object Oriented Inheritance and Operator Overloading
21 min
08: GUI - Introduction to Tkinter
11 min
09: More on Tkinter - Frames
7 min
10: More Tkinter Widgets
15 min
11: Regular Expressions
17 min
12: More on Regular Expressions
14 min
13: Wrapping up Regular Expressions
5 min
14: Introduction to Threads
15 min
15: Working with Threads
18 min
16: Introduction to Network Programming with Python
15 min
17: SocketServer
6 min
18: More Network Modules
9 min
19: Python and SQL Part 1
11 min
20: Python and SQL Part 2
12 min
21: Extending Python with C Part 1
11 min
22: Extending Python with C Part 2
15 min
23: SWIG Part 1
8 min
24: SWIG Part 2
15 min
25: Moving from Python 2 to Python 3
19 min
Course Survey
View all course details

Module 00: Course Introduction

Module 01: Miscellaneous Tidbits

  • Named Parameters
  • pprint Module
  • lamdas
  • Generators
  • Lab: Generators and lambdas

Module 02: Complex Data Types Part 1

  • List of Lists
  • Processing List of Lists
  • List of Dictionaries
  • Lab: Working with List of Dictionaries

Module 03: Complex Data Types Part 2

  • Dictionary of Lists
  • Working with Dictionary of Lists
  • Dictionary of Dictionaries
  • Lab: Working with Dictionary of Dictionaries

Module 04: Arbitrarily Nested Types

  • Introduction to Nested Types
  • Different Nested Types
  • Nested Type Example
  • Lab: Working with Nested Types

Module 05: Object Oriented Review

  • Creating a Class
  • Object Constructor
  • The from statement
  • Composition
  • Lab: Creating a Class, Working with the Class

Module 06: More Object-Oriented Topics

  • Static Variables and Methods
  • Destructor
  • Method Overloading
  • Data Hiding
  • Lab: Working with Static Data and Data Hiding

Module 07: Object Oriented Inheritance and Operator Overloading

  • Inheritance
  • Multiple Inheritance
  • Abstract Base Classes
  • Operator Overloading
  • Object Iterators
  • Lab: Implementing Inheritance

Module 08: GUI - Introduction to Tkinter

  • Introduction to Tkinter
  • More on Labels
  • The pack() function
  • Lab: Using pack()

Module 09: More on Tkinter - Frames

  • Introduction to Frames
  • Frame Examples
  • Frames and Classes

Module 10: More Tkinter Widgets

  • Buttons
  • Checkbuttons
  • Radiobuttons
  • Entry
  • More Topics
  • Lab: Creating a Frame

Module 11: Regular Expressions

  • Introduction to Regular Expressions
  • Text Matching
  • Patterns
  • Patterns: Classes and Quantifiers
  • Exercise: Regex

Module 12: More on Regular Expressions

  • Match Object
  • Memory with Parens
  • Memory and group()
  • Alternation and Anchoring Patterns
  • Exercise: Case Insensitive Matching

Module 13: Wrapping up Regular Expressions

  • The split() Method
  • Lab: Matching Text and Extracting Text

Module 14: Introduction to Threads

  • Introduction to Threads
  • Creating a Python Thread
  • Creating Multiple Threads
  • Joining Threads
  • Threads with Data
  • Lab: Creating Threads

Module 15: Working with Threads

  • Removing the Flag Variable
  • The Lock and RLock Classes
  • Using try/finally
  • Semaphors
  • Lab: Thread Synchronization

Module 16: Introduction to Network Programming with Python

  • Introduction to Network Programming
  • Writing a Server from Scratch
  • Writing a Client from Scratch
  • Handling Multiple Clients Serially
  • Handling Multiple Clients in Parallel
  • Lab: Write a Client/Server Program

Module 17: SocketServer

  • Using SocketServer
  • Forking with SocketServer
  • Threading with SocketServer

Module 18: More Network Modules

  • telnetlib
  • ftplib
  • urllib
  • Lab: using ftplib and telnetlib

Module 19: Python and SQL Part 1

  • Introduction to SQL
  • MySQL Example
  • MySQLdb Module
  • Connecting to a Database
  • Executing a Query

Module 20: Python and SQL Part 2

  • Other Ways of Fetching a Result
  • Inserting into a Table
  • Lab: Working with MySQLdb

Module 21: Extending Python with C Part 1

  • Introduction
  • Simple Example
  • Pieces of the C File

Module 22: Extending Python with C Part 2

  • PyArg_Parse()
  • Py_BuildValue()
  • Conversion Codes
  • Error Handling
  • An Example
  • Lab: Putting it Together

Module 23: SWIG Part 1

  • Introduction to SWIG
  • SWIG Example
  • Lab: Using SWIG

Module 24: SWIG Part 2

  • SWIG Wrapping Existing Code
  • Global Variable
  • SWIG and Structs
  • Lab: Using Global Variables with SWIG
Module 25: Moving from Python 2 to Python 3
  • Common gotchas
  • Syntax changes
  • String formatting
  • Changes to exceptions
  • Miscellaneous stuff
  • Porting from Python 2.x to Python 3.x
View all course details
In order to successfully complete Advanced Python 3 Programming you need to have experience in a high-level programming language (for example: C, C++, Java, Perl, etc.), be able to perform basic operations in the operating systems and have completed Python 3 Programming Essentials. If you do not have this experience, the following GogoTraining courses are available for you to choose from:
View all course details
This iOS 8 course will show you how to write mobile applications for Apple’s popular iPhone and iPad. This course is fully updated for Xcode 6, iOS 8, and Objective-C.  You’ll begin the course by learning how to use Xcode 6 to build and debug iOS 8 applications that run on the iOS Simulator. You will then learn how iOS 8 applications display views, learn to use view controllers, display alerts, play multimedia, and more. At the end of the course you will have written 10 apps and be able to write your own iPhone and iPad apps.
 
This course includes over 18 lecture and 7.7 hours of video instructions.  In this course you will create 10 apps including a Touch Counter App that responds to your touches on the screen and increments a counter;  a touch counter app using buttons; a name and phone number app; a text editor app; an input control fun app; an HTML app; a stock price app, an email and text app; an image app and an audio app.  And all of these apps and exercises will prepare you to create your own iPhone and iPad apps.
View all course details Enroll Now
Video Title
Length
Lesson 1: Introduction to Xcode 6
25 min
Lesson 2: iOS 8 Application Concepts
23 min
Lesson 3: Displaying Text With UILabel
22 min
Lesson 4: Displaying Buttons With UIButton
21 min
Lesson 5: Keyboard Input with UITextField
25 min
Lesson 6: Using UITextView
22 min
Lesson 7: Alerting Users
21 min
Lesson 8: More Touch Input Controls
24 min
Lesson 9: Displaying HTML with UIWebView
23 min
Lesson 10: Accessing Web Services
27 min
Lesson 11: Working with Images
23 min
Lesson 13: Two View Controllers with XIBs
23 min
Lesson 14: Multiple Controllers with Storyboards
23 min
Lesson 15: Navigation Controller
24 min
Lesson 16: Tab Bar Controller
25 min
Lesson 17: Table View Controller
22 min
Lesson 18: Playing Audio
23 min
Course Survey
View all course details
Module 00: Course Introduction - iOS 8 Programming
 
Module 01: Introduction to Xcode 6 
  • Starting Up Xcode
  • Creating a new Xcode Project
  • Project Templates and Options
  • Building, Running, and Stopping
  • Show/Hide Navigator
  • Show/Hide Tools/Utilities
  • Demo: Tour of Xcode 6
Module 02: iOS 8 Application Concepts 
  • Application Startup, Delegate and Lifecycle
  • MVC – Model, View, Controller
  • Main Storyboard 
  • Launch Screen 
  • Image Assets
  • Info.plist
  • Demo: Tour of an iOS 8 App
Module 03: Displaying Text With UILabel 
  • UILabel and IBOutlet
  • UILabel as Plain Text
  • UILabel as Attributed Text 
  • UILabel as Multi-Line Text
  • Demo:  Exploring UILabel
  • Exercise: Creating a Touch Counter App with UILabel
Module 04: Displaying Buttons With UIButton 
  • UIButotn and IBAction
  • UIButton and IBOutlet
  • Demo: Exploring UIButton
  • Exercise: Creating a Touch Counter App with UIButton
Module 05: Keyboard Input with UITextField 
  • About Keyboard Input
  • Keyboard Choices
  • Keyboard Input using UITextField
  • Demo: Exploring Keyboard Input
  • Exercise: Keyboard Input of Name and Phone Number
Module 06: Using UITextView 
  • About UITextView
  • UITextView for Text Output
  • UITextView for Keyboard Input
  • Demo: Exploring UITextView
  • Exercise: Using UITextView as Simple Editor
Module 07: Alerting Users 
  • Alerting Users Options
  • Alerting Users with UIAlertView
  • Alerting Users with UIActionSheet
  • Alerting Users with UIAlertController
  • Demo: Exploring Alerting Users
  • Exercise: Alerting User While Filling Out Form 
Module 08: More Touch Input Controls 
  • Switch
  • Segmented Control
  • Slider
  • Stepper
  • Date Picker and Picker View
  • Demo: Exploring More Touch Input Controls
  • Exercise: Input Control Fun and Saving State
Module 09: Displaying HTML with UIWebView 
  • About UIWebView
  • Display URL in Browser
  • Displaying HTML Strings
  • Displaying HTML Files
  • Displaying HTML URLs
  • Demo: Exploring UIWebView
  • Exercise: Using UIWebView
Module 10: Accessing Web Services 
  • About Web Service Access
  • -[NSString stringWithContentsOfURL:]
  • NSURLConnection
  • Demo: Exploring Web Services
  • Exercise: Accessing Stock Price Web Service
Module 11: Working with Images 
  • Image Use in iOS 8
  • Image Assets
  • Using UIImage
  • Using UIImageView   
  • Image Animation
  • Demo: Exploring Images
  • Exercise: Images and Animation
Module 12: Sending Email and Text 
  • MessageUI Framework
  • About Sending Email
  • About Sending Text
  • Demo: Exploring Sending Email and Text
  • Exercise: Sending Email and Text
Module 13: Two View Controllers with XIBs
  • Concepts of Multiple View Controllers
  • Creating XIB Files
  • Sending Data Into XIB Files
  • Receiving Data from XIB Files
  • Demo: Exploring Multiple View Controllers with XIBs
  • Exercise: Sending the Count To/From Two View Controllers
Module 14: Multiple Controllers with Storyboards
  • About Storyboard File
  • Creating View Controllers in Storyboards
  • Sending Data using Segues
  • Receiving Data from Storyboards
  • Demo: Exploring Storyboards
  • Exercise: Sending/Receiving Data Using Storyboards
Module 15: Navigation Controller 
  • About Navigation Controller
  • Using Navigation Controller at Runtime
  • Using Navigation Controller with Storyboard
  • Using Segue and Delegate to send/receive data
  • Demo: Exploring Navigation Controller
  • Exercise: Using Navigation Controller
Module 16: Tab Bar Controller 
  • About Tab Bar Controller
  • Using Tab Bar Controller at Runtime
  • Using Tab Bar Controllers with Storyboard
  • Using Data Model with Tab Bar Controller
  • Demo: Exploring Tab Bar Controller
  • Exercise: Using Tab Bar Controller
Module 17: Table View Controller 
  • About Table View Controller
  • Table View Controller at Runtime
  • Table View Controller with Storyboard – Static
  • Table View Controller with Storyboard - Dynamic
  • Demo: Exploring Table View Controller
  • Exercise: Using Table View Controller
Module 18: Playing Audio
  • Playing Audio with  AudioToolbox
  • Playing Audio with AVFoundation
  • Playing Audio/Video with MediaPlayer
  • Playing Audio/Video with AVKit
  • Demo: Exploring Playing Audio
  • Exercise: Playing Audio
View all course details

Completion of Objective-C Programming Using Xcode 6 from GogoTraining or equivalent experience. 

View all course details

This course will show you how to quickly and easily write applications for Android mobile devices, including both phones and tablets. This course is fully updated for Android 5 (Lollipop) and uses the latest development tools, including Android Studio and the Android version of Eclipse. You’ll begin the course by learning how to use either Android Studio or Eclipse (your choice!) to build and debug Android 5 (Lollipop) applications that run on the Android Simulator. You’ll learn how Android 5 applications display views, use widgets, use single and multiple activities, and more. At the end of the course you will have the foundation skills to develop and support Android 5 applications. You will also have the skills to take the follow-on Advanced Android 5 Programming course.

View all course details Enroll Now
Video Title
Length
01: Introduction to Android 5
22 min
02: Eclipse ADT
19 min
03: Android Studio Beta
14 min
04: Android SDK Manager
22 min
05: Android Virtual Device Manager
23 min
06: Hello Android App Using Eclipse
23 min
07: Hello Android App Using Android Studio Beta
16 min
08: Activity and View Class
22 min
10: TextView Widget Using Java
24 min
11: TextView Widget Using XML
23 min
12: Button Widget Using Java
22 min
13: Button Widget Using XML Layout
23 min
14: Keyboard Input with EditText
22 min
15: List Activity Using Java
23 min
16: List Activity Using XML
22 min
17: Using Intents
27 min
18: Creating Activities
25 min
Course Survey
View all course details
Module 00: Course Introduction - Introduction to Android 5 Programming
 
Module 01: Introduction to Android 5
  • Android As World’s Most Popular Mobile Device
  • Development Framework
  • Android Dashboard
  • Android Development Tool Choices
  • Android Block Diagram
  • Android Documentation
  • Demo: Tour of developer.android.com
Module 02: Eclipse ADT
  • About Eclipse ADT Bundle
  • System Requirements
  • Downloading and Installing
  • Starting Up Eclipse ADT
  • Creating A New Android Project
  • Selecting the Application Template
  • Entering Project Options
  • Building, Running, and Stopping
  • Lab Exercise: Download and Install Eclipse ADT
  • Demo: Verifying your installation of Eclipse ADT
Module 03: Android Studio Beta
  • About Android Studio
  • System Requirements
  • Downloading and Installing
  • Starting Up Android Studio
  • Creating A New Android Project
  • Selecting the Application Template
  • Entering Project Options
  • Building, Running, and Stopping
  • Lab Exercise: Download and Install Android Studio
  • Demo: Verifying your installation of Android Studio
Module 04: Android SDK Manager
  • About Android SDK Manager
  • Startup from Eclipse
  • Startup from Android Studio
  • Checking Installation Status
  • Downloading New Updates
  • Android APIs compared to Google APIs
  • Lab Exercise: Download and Install Android SDK Manager
  • Demo: Verify Latest Software Versions of the Android SDK 
Module 05: Android Virtual Device Manager
  • About Android Virtual Device Manager
  • Startup from Eclipse
  • Startup from Android Studio
  • Creating New AVDs
  • Starting AVDs
  • Common Issues/Troubleshooting
  • Lab Exercise: Creating an Android Virtual Device
  • Demo: Tour of and Creating Android Virtual Device Manager
Module 06: Hello Android App Using Eclipse
  • Creating New Project
  • Configuring the Project
  • Configuring Launch Icons
  • Creating Blank Activity
  • Project Workspace
  • Running/Stopping the App
  • Demo: Building Android Hello App With Eclipse
  • Exercise: Creating Hello Android Using Eclipse
Module 07: Hello Android App Using Android Studio Beta
  • Creating New Project
  • Configuring the Project
  • Configuring Launch Icons
  • Creating Blank Activity
  • Project Workspace
  • Running/Stopping the App
  • Demo: Building Android Hello App With Android Studio
  • Exercise: Creating Hello Android Using Android Studio
Module 08: Activity and View Class
  • Activity Class
  • View Class
  • Application Lifecycle
  • MVC – Model, View, Controller
  • Resources
  • Android Manifest
  • Demo: Exploring Activities
  • Exercise: Creating a Flashlight App
Module 09: Android Widgets
  • About Android Widgets
  • Selected Widgets
  • Widget Design Pattern With Java Code
  • Widget Design Pattern With XML Layout
  • Selected Widgets
  • Toast
Module 10: TextView Widget Using Java
  • TextView using Java
  • TextView Properties and Methods
  • TextView using XML Layout
  • TextView XML Attributes
  • Demo:  Exploring TextView with Java
  • Exercise: Creating a Touch Counter App with TextView using Java
Module 11: TextView Widget Using XML
  • TextView XML Layout
  • Using findViewById()
  • activity_main.xml
  • MainActivity.java
  • Debugging Code Crash
  • Demo:  Exploring TextView with XML Layout
  • Exercise: Creating a Touch Counter App with TextView using XML
Module 12: Button Widget Using Java
  • About Button Widget Class
  • Common Design Patterns
  • Creating Button in Java
  • Listening for Button Clicks
  • Demo: Exploring Button Class
  • Exercise: Creating a Touch Counter App with Button using Java
Module 13: Button Widget Using XML Layout
  • About Button Widget XML Layout
  • Creating XML Layout
  • Handling Button Click in XML
  • Handling Button Click in Java
  • Demo: Exploring Button Class
  • Exercise: Creating a Touch Counter App with Button using XML
Module 14: Keyboard Input with EditText  
  • About Keyboard Input
  • Keyboard Choices
  • Keyboard Input using EditText (Single-Line Input)
  • Demo: Exploring Keyboard Input
  • Exercise: Keyboard Input of Name and Phone Number
Module 15: List Activity Using Java
  • About List Activity
  • List Activity Design Pattern
  • List Activity Data Source
  • Array Adapter
  • Demo: Exploring List Activity
  • Exercise: Exploring List Activity
Module 16: List Activity Using XML
  • ListActivity XML Layout Pattern
  • Important ID: @android:id/list
  • Important ID: @android:id/empty
  • Demo: Exploring List Activity with XML
  • Exercise: Exploring List Activity with XML 
Module 17: Using Intents
  • About Intents
  • Intent Common Design Patterns
  • Intents and Starting Activities
  • Selected System Defined Intents
  • Intents and Permissions
  • Demo: Exploring Intents
  • Exercise: Exploring Intents
Module 18: Creating Activities
  • Apps With Multiple Activities
  • Creating Activities Design Pattern
  • Using Intents to Start to Activities
  • Ending Activities
  • Demo: Creating Activities
  • Exercise: Creating Activities
View all course details
Completion of the Java Programming courses from GogoTraining below or equivalent experience. 
View all course details

This course builds upon the skills you learned in the previous Introduction to Android 5 Programming course. You will learn how to read and write data, how to use HTML5 in WebView, how to access web services, how to become a broadcast receiver and how to write a service. The course is fully updated for Android 5 (Lollipop) and uses the latest development tools, including Android Studio and the Android version of Eclipse. At the end of the course you’ll have the skills to develop, support, and debug Advanced Android 5 applications.

View all course details Enroll Now
Video Title
Length
01: Multiple Activities
29 min
02: Bundle Storage
15 min
03: Shared Preference Storage
25 min
04: File Storage
24 min
05: SQLite Database Storage
23 min
06: Android Graphics
25 min
07: Android Audio
17 min
08: Android Camera
20 min
09: Android Video
18 min
10: Displaying HTML with WebView
19 min
11: Accessing Web Services
29 min
12: Broadcast Receivers
21 min
14: Using Android Services
26 min
15: Creating Android Services
22 min
16: Using Content Providers
22 min
17: Creating a Content Provider
18 min
Course Survey
View all course details
Module 00: Course Introduction - Advanced Android 5 Programming
 
Module 01: Multiple Activities
  • The Main Activity
  • Other Activities
  • Sending Data Into an Activity
  • Receiving Results from an Activity
  • Demo: Exploring Multiple Activities
  • Exercise: Sending and Receiving Data To/From Activities
Module 02: Bundle Storage
  • Android Storage Options
  • About Bundle Storage
  • Using Bundle Storage
  • Demo: Exploring Bundle Storage
  • Exercise: Using Bundle Storage
Module 03: Shared Preference Storage
  • About Shared Preference Storage
  • Using Shared Preference Storage
  • Demo: Exploring Shared Preference Storage
  • Exercise: Using Shared Preference Storage
Module 04: File Storage
  • Basics of File Storage 
  • Internal File Storage
  • External File Storage
  • Using File Storage
  • Demo: Exploring File I/O Storage
  • Exercise: Using File I/O Storage
Module 05: SQLite Database Storage
  • About Database Storage
  • SQLite Classes
  • SQLite Helper Classes
  • Using SQLite Helper Classes
  • Demo: Exploring SQLite Database Storage
  • Exercise: Using SQLite Database Storage
Module 06: Android Graphics
  • Android Graphics Options
  • View Class
  • Canvas Class
  • Paint Class
  • Demo: Exploring Android Graphics
  • Exercise: Using Android Graphics
Module 07: Android Audio
  • Android Audio Basics
  • Media Player Class
  • Playing Audio
  • Recording Audio
  • Demo: Exploring Android Audio
  • Exercise: Using Android Audio
Module 08: Android Camera
  • About Android Camera
  • Using the Camera
  • Receiving Photos from Camera
  • Displaying Photos
  • Demo: Exploring Android Camera
  • Exercise: Using Android Camera
Module 09: Android Video
  • Basics of Android Video
  • Using the Video Recorder
  • Receiving Video
  • Playing Video
  • Demo: Exploring Android Video
  • Exercise: Using Android Video
Module 10: Displaying HTML with WebView
  • About WebView
  • Display URL in Browser
  • Displaying Internal HTML
  • Displaying External HTML
  • Demo: Exploring WebView
  • Exercise: Using WebView
Module 11: Accessing Web Services
  • Web Service Access Basics
  • Stock Quote Web Service
  • Network Access and Threading
  • HttpClient, HttpGet, HttpResponse
  • Demo: Exploring Web Services
  • Exercise: Accessing a Stock Quote Web Service
Module 12: Broadcast Receivers
  • About Broadcast Receivers
  • Broadcast Receivers at Run-time
  • Broadcast Receivers at Install-Time
  • Demo: Exploring Broadcast Receivers
  • Exercise: Using Broadcast Receivers
Module 13: Sending Broadcasts
  • Basics of Sending Broadcasts
  • Broadcast Naming
  • Sending Data In Broadcasts
  • Demo: Exploring Sending Broadcasts
  • Exercise: Using Custom Broadcasts Receivers
Module 14: Using Android Services
  • About Android Services
  • Account Service
  • Alarm Service
  • Other Services
  • Demo: Exploring Using Android Services
  • Exercise: Using Android Services
Module 15: Creating Android Services
  • Android Services Basics
  • Service Class
  • Start/Stop Service
  • Binding to a Service
  • Demo: Exploring Creating Android Services
  • Exercise: Creating Android Services
Module 16: Using Content Providers
  • About Content Providers
  • Contact Provider
  • Video Provider
  • Other Providers
  • Demo: Exploring Using Content Provider
  • Exercise: Using Content Providers
Module 17: Creating a Content Provider
  • Introduction to Master/Detail Flow
  • Master/Detail Template
  • List Activity and List Fragment
  • Detail Activity and Detail Fragment
  • Master/Detail on Phone  and Table Devices
  • Demo: Exploring Master/Detail Activities
  • Exercise: Using Master/Detail Activities
View all course details

Completion of GogoTraining’s Introduction to Android 5 Programming course or equivalent experience.

View all course details

Introduction to Perl Part 1 online training provides you with a basic introduction to the Perl language. You will learn about scalar data, arrays, branching and looping, input and output, regular expressions and functions. You will learn how to write scripts using the fundamental Perl building blocks in this Perl training course.

Once you have completed Introduction to Perl Part 1 the next course in this series is Introduction to Perl Part 2. The Introduction to Perl Part 2 course will enhance your programming knowledge by discussing file handles and file tests, formatted output, accessing directories, file and directory manipulation, managing OS processes, string manipulation and sorting, hash files and text management, and some advanced topics.  Click here to learn more about Introduction to Perl Part 2.

Download the course outline.

View all course details Enroll Now
Video Title
Length
01: Introduction to Perl
32 min
02: Scalar Data
43 min
03: Arrays
33 min
04: Branching and Looping
33 min
05: Hashes
31 min
06: Input and Output
39 min
07: Regular Expressions Part 1
44 min
08: Regular Expressions Part 2
33 min
10: Passing values to Functions
25 min
11: Course Summary & Evaluation
2 min
Course Survey
View all course details

Module 00: Introduction to Perl Part 1 Online Training - Course Introduction

Module 01: Introduction to Perl
•    Introduction to Perl
•    History of Perl
•    Description of Perl
•    Basic concepts

Module 02: Scalar Data
•    Scalar values
•    Operators
•    Scalar variables
•    Operations on scalar of variables
•    Safe coding practices

Module 03: Arrays
•    Array variables
•    Array access
•    Using STDIN with an array
•    Arrays Lab

Module 04: Branching and Looping
•    Statement blocks
•    Statements
•    If/unless conditionals
•    While/until loops
•    For and for each loops
•    Do loops
•    Branching and Looping Lab

Module 05: Hashes
•    Hash what is it?
•    Operators
•    Hash Slices
•    Hashes Lab

Module 06: Input and Output
•    Input operators
•    Output operators
•    Print / printf
•    Here documents
•    Input and Output Lab

Module 07: Regular Expressions Part 1
•    Regular expressions
•    Patterns
•    Grouping patterns
•    Operator precedents

Module 08: Regular Expressions Part 2
•    Matching operator variants
•    Substitutions
•    Other operators
•    Regular expression options
•    Regular Expression Lab

Module 09: Functions
•    System and user defined functions
•    Return values and arguments

Module 10: Passing values to Functions
•    Variable number of parameters
•    Pass by reference or value
•    Passing Values to Functions Lab

Module 11: Introduction to Perl Part 1 Online Training - Course Summary

View all course details

You need to have some previous programming language experience.  If you do not have this experience, we recommend the following GogoTraining courses:

 

View all course details

Introduction to Perl Part 2 online training course covers file handles and file tests, formatted output, accessing directories, file and directory manipulation, managing OS processes, string manipulation and sorting, hash files and text management, and some advanced topics.

In order to take this course you need to have taken Introduction to Perl Part 1 and have previous programming language experience.

Download the course outline.

View all course details Enroll Now
Video Title
Length
01: Loop and Flow Modifiers
33 min
02: File Handles
37 min
03: File Tests
38 min
04: Formatted Output
39 min
05: Accessing Directories
33 min
06: File and Directory Access
37 min
07: Managing Operating System Processes
33 min
08: String Manipulation and Sorting Part 1
31 min
09: String Manipulation and Sorting Part 2
29 min
11: Advanced Topics Overview
35 min
12: Course Summary & Evaluation
4 min
Course Survey
View all course details

Module 00: Introduction to Perl Part 2 Online Training - Course Introduction

Module 01: Loop and Flow Modifiers
•    Introduction
•    Last/next/redo operators
•    Naked block
•    Labeled block
•    Goto
•    Expression modifiers
•    &&, || and ?: as control structures
•    Loop and Flow Modifiers Lab

Module 02: File Handles
•    Filehandle - what is it?
•    Opening / closing a filehandle
•    Using filehandles

Module 03: File Tests
•    ARGV array
•    File tests
•    Stat and lstat operators
•    File Tests Lab

Module 04: Formatted Output
•    Defining a format
•    Invoking a format
•    More about fieldholders
•    More about formats
•    Formatted Output Lab

Module 05: Accessing Directories
•    Moving around the directory tree
•    Globbing
•    Directory handles
•    Accessing Directories Lab

Module 06: File and Directory Access
•    Working with files
•    Command-line arguments
•    File and Directory Access Lab

Module 07: Managing Operating System Processes
•    The system function
•    The environment
•    Backquotes
•    Processes as filehandles
•    Sending a file to the printer
•    Using the fork and exec functions
•    Managing Operating System Processes Lab

Module 08: String Manipulation and Sorting Part 1
•    Working with substrings
•    String manipulation with splice
•    Formatting data with sprintf

Module 09: String Manipulation and Sorting Part 2
•    Advanced sorting
•    Transliteration
•    String Manipulation and Sorting Lab

Module 10: Hash Files and Text Management
•    DBM databases and DBM arrays
•    Fixed length random access databases
•    Variable length (text) databases
•    Hash Files and Text Management Lab

Module 11: Advanced Topics Overview
•    Introduction
•    Map
•    Grep
•    Advanced Topics Overview Lab

Module 12: References
•    References
•    Hashes of hashes

Module 13: Introduction to Perl Part 2 Online Training - Course Summary

View all course details

You need to have some previous programming language experience and have completed Introduction to Perl Part 1If you do not have this experience, we recommend the following GogoTraining courses:

View all course details
In the emerging world of IoT there is a need for embedded devices with much smaller processors that cannot support Linux or Android, the common operating systems for embedded computing devices. Today with the advent of very effective and efficient real-time operating systems like FreeRTOS, a popular small processor Open Source operating system, programmers can take advantage of all the great features operating systems offer.
 
This course explores concepts of real-time and multi-tasking programming using Free RTOS, a minimal operating system that does not have layer upon layer of software abstractions. It puts programmers close to the hardware, what software engineers call “programming down to the bare metal”.   While there are a number of operating systems to choose from in designing small microcontrollers, FreeRTOS offers the following great features:
  • It’s Open Source. That means it’s “free”. There’s also a commercial version available that provides support from the developers if you need it.
  • It’s simple. A basic FreeRTOS system is on the order of five or six C source files. You can actually wrap your mind around it. By contrast, a minimal Linux or Android build is on the order of a thousand source files. Wrap your mind around that dude!
  • As a consequence of being simple, it’s also small. A reasonable system will fit in 6 KB of memory.
  • Despite being simple, it’s comprehensive. It provides the facilities required to address the basic real-time programming problems.
  • The source code is high quality. It’s readable! There are lots of useful comments and the symbol names are expressive, that is they convey what the symbol actually does. In contrast to much of Linux code, which I characterize as write-only. Someone obviously wrote it, but no one else can read it because there are no comments.

In this class you will perform hands-on lab exercises that teach you how to design reliable embedded devices for the Internet of Things and you will gain an understanding of how multi-tasking operating systems lead to more robust, scalable, and maintainable designs.

View all course details Enroll Now
Video Title
Length
01: Introducing Multitasking
23 min
02: Introducing FreeRTOS
19 min
03: The Development Environment
13 min
04: Building and Running an Eclipse Project
22 min
05: Tasking Model
15 min
06: Synchronization: Mutexes and Semaphores
15 min
08: Interrupt Management
14 min
09: Memory and Time Management
10 min
10: Network Programming
20 min
11: Advanced Networking
15 min
12: Internals of Free RTOS
15 min
13: Survey of Other Multitasking OSes
16 min
Course Survey
View all course details
Module 00: Course Introduction - Microcontroller Programming for the Internet of Things Using FreeRTOS
 
Module 01: Introducing Multitasking 
  • The nature of Device Programming
  • What is “real-time”?

        o   Hard vs. Soft Real-Time

  • Polling Loop
  • Asynchronous Events—Interrupts
  • The Multitasking Model
Module 02: Introducing FreeRTOS 
  • The nature of Open Source
  • FreeRTOS Exceptions to the GPL
  • FreeRTOS Features
  • Naming Conventions in FreeRTOS Source Code
  • Get and Install FreeRTOS
  • Demo: Getting and installing FreeRTOS
  • Lab Exercise: Getting and Installing FreeRTOS
Module 03: The Development Environment
  • Download and Install LPCExpresso
  • LPC1769 Target Board and Base Board
  • Demo: Install LPCExpresso
  • Lab Exercise: Install LPCExpresso
  • Eclipse
Module 04: Building and Running an Eclipse Project
  • Get Sample Program
  • Demo: Build and Run Sample Program
  • Lab Exercise: Build and Run Sample Program
Module 05: Tasking Model
  • Creating Tasks

        o   Task State Machine

  • Setting Priority
  • Deleting Tasks
  • The Idle Task

        o   Idle Task Hook

  • Demo: Tasking Model Example
  • Lab exercise: Managing Tasks
Module 06: Synchronization: Mutexes and Semaphores
  • The Need for Synchronization
  • Critical Sections
  • Stopping the Scheduler
  • Kernel Services
Module 07: Communication: Message queues
  • What is a message queue?
  • Creating Message Queues
  • Sending to a Queue

        o   Block if Queue Full

  • Receiving From a Queue

        o   Block if Queue Empty

  • “Gatekeeper” Task
  • The FreeRTOS Simulator

        o   Getting and Installing MinGW

  • Lab exercise: Implementing printf with a Gatekeeper Tasks
Module 08: Interrupt Management
  • Interrupt Context

        o   xxxFromISR() Functions

  • Cortex M3 Nested Vectored Interrupt Controller  
  • Deferred interrupt Processing
  • Lab Exercise: Measuring Interrupt Latency 
Module 09: Memory and Time Management
  • Problems with malloc()
  • FreeRTOS Use of Dynamic Memory
  • Alternate Implementations
  • Delaying a Task
  • Software Timers
Module 10: Network Programming 
  • Sockets

        o   Sockets APIs

        o   “Zero-copy” Semantics

  • User Datagram Protocol (UDP)
  • What about TCP?
  • Demo: Code Review
  • Lab Exercise: Code Review
Module 11: Advanced Networking
  • Nabto Platform

        o   What is it?

        o   Components

        o   NAT Traversal

  • Demo: Nabto
  • Lab Exercise: Nabto
Module 12: Internals of Free RTOS
  • Performance and Debugging Facilities

        o   “Hook” Functions

        o   Trace Macros

  • Kernel internals

        o   List Management

        o   The Scheduler

Module 13: Survey of Other Multitasking OSes
  • MicroC/OS
  • Nutrino

        o   Protected Memory

  • Monolithic vs. Message Passing Kernels
View all course details

Experience and fluency with the C programming language is expected or taking these courses below:

Some familiarity with microcontroller hardware is useful.

View all course details

Get Started Learning

Coding / Programming Today!

Norman McEntire

Norman McEntire founded Servin Corporation in 1995 to focus on “Software Technology Training for Software Technology Professionals(tm). Since that time, Norman has used his unique  training style to train thousands of software developers in nearly every major technology company, including Avaya, Broadcom, Cubic, Dell, Fidelity, HP, IBM, Intel, Intuit, Motorola, NCR, Qualcomm, Wells Fargo, and many more. With degrees in Computer Engineering, Norman has designed and built everything from low-level chips, boards, and complete computer systems, to software at all levels, including device drivers, systems software, and end-user software for the desktop, web, and mobile.

Tim R. Norton

Dr. Norton has worked with a variety of computer systems of all sizes and many operating systems, including MVS, Windows and Unix/Linux. He has experience with applications design, support, and systems programming. He has done Technology Planning, Capacity Planning and Capacity Modeling for over 20 years at a variety of large companies. He co-foundered and was the Chief Scientist of a start-up company to provide web based capacity planning services for web applications. He has been a full-time Professor at a local university and continues to teach at universities in Colorado Springs. He is active in CMG (Computer Measurement Group), the leading computer performance analysis organization, and has been the Subject Area Chair for every year since 2000. He has participated in Colorado Governor Owens' Technology Summit. He has served on the Academic Advisory Boards for Computer Science at Colorado Technical University and at DeVry University of Colorado. He founded Simalytic Solutions, LLC in 1995 to provide capacity planning and application modeling services using the Simalytic® Modeling Technique and the Response Time Pipe™ that he developed as a result of his doctorial research.

Donna Martin

I am primarily a C Programmer - having first learned C at the university in 81.  My professional work has focused on computer graphics/user interfaces, and C is the language I have worked with for almost 3 decades (makes me feel younger than saying 30 years!).  I have worked in the training field since the 90s, and have taught programming at a University Engineering College as well as many training seminars in programming, graphics, UNIX/Linux.  The majority of my work has involved UNIX/Linux systems.

James Lee

James Lee is a hacker and open-source advocate based in Illinois. He holds a master's degree from Northwestern University, and he can often be seen rooting for the Wildcats during football season. As founder of Onsight, Lee has worked as a programmer, trainer, manager, writer, and open-source advocate. Lee authored Beginning Perl, Second Edition published by Apress and coauthored Hacking Linux Exposed, Second Edition, as well as Open Source Web Development with LAMP. He enjoys hacking in Perl and Python and has written programming articles for the Linux Journal. Lee also enjoys developing software for the Web, reading, traveling and, most of all, snowboarding with his kids who are old enough now to understand why dad's favorite animals are penguins and camels and why dad laughs at Monty Python's Flying Circus.

Tom Vaughan

I have been involved with IT technial training for 14+ years. I have taught and created material for Perl and UNIX shells. I am a contract trainer and have taught for HP, IBM, Sun, Lockheed, Intel, NASA, Fedex, the USAF, the US Army and the US Navy as well as many classes with an open or public audience.

 

I love teaching and learn something new from every class.

Doug Abbott

Doug Abbott is a consultant, author, and trainer with over thirty years experience in the computing field. He has done both hardware and software design primarily in the area of data acquisition and instrumentation. As a software engineer, his focus has been on the operating system and device driver level with a particular emphasis on embedded applications of Linux.

As an instructor, Mr. Abbott has developed and taught several courses--both in-person and on-line--for UC Berkeley Extension and UC San Diego Extension. These classes have also been presented on-site to a number of well-known institutions including NASA Houston, Wind River Systems, Jet Propulsion Laboratory, and TRW among others.

Doug is the author of three books:

     Embedded Linux Development using Eclipse

     Linux for Embedded and Real-time Applications, 2nd Ed.

     PCI Bus Demystified, 2nd Ed.

Doug has both a bachelor's and master's degree in electrical engineering from UC Berkeley. He is a member of the Professional and Technical Consultants Association (PATCA).

 

Transcript

This course comes with a Transcript that tracks your progress. You can use your transcript to view and monitor your progress and when you complete the course, you can print or email the transcript, or print a course completion certificate.

Certificate of Completion

When you complete this course you will receive a Course Completion Certificate Download Link so you can print and/or email your Certificate of Completion.

Sample of Certification of Completion

QA Forum

When you purchase this course you will be able to use the QA Forum and have direct access to the instructor.