|
svnusr |
Subversion for Users |
7 hours |
This course has been created for people who need to work co-operatively. The course explains the concepts of merges, conflicts, branches, revisions and diff files. Participants will learn how to use command line tools as well as GUIs like Tortoise.
Repository Basics
What is a repository
What should be stored in a repository
Tracking file changes and history
Repository URL and protocols
Working With Revisions
Import project
Concept of working copies
Checking out and exporting
Checking in and writing log messages
Solving conflicts
Finding differences between revisions and working copy files
Reverting changes
Adding new files to the repository
Removing, moving and renaming files in the repository and working copy
Creating snapshots with tagging
Switching files to a certain moment in the past
Sharing Files
Locking and unlocking file
The Lock-Modify-Unlock Solution versus Copy-Modify-Merge Solution
Branching and Merging
Creating branches
Merging changes
Troubleshooting
How to deal with not properly moved or copied files and folders
Dealing with multiple working copies
|
|
gitusers |
Git for Users |
7 hours |
This course has been created for everyone who is going to use Git repository.
Software developers, project managers, software architects and solutions architects, release managers, etc...
Git Overview
Installing Git
Short History of Git
What is Git?
Git Concepts
Focus and Design
Git Object Types
The Git Data Model
Branching and Merging
The Treeish
The Git Directory
Working Directory
The Index
Non-SCM Uses of Git
Git in Practice
Setting Up Your Profile
Getting a Git Repository
Normal Workflow Examples
Log - the Commit History
Browsing Git
Git Diff
Branching
Simple Merging
Stashing
Tagging
Exporting Git
Distributed Workflow Examples
Sharing Repositories
Hosted Repositories
|
|
progbio |
Programming for Biologists |
28 hours |
This is a practical course, which shows why programming is a powerful tool in the context of solving biological problems. During the course participants will be taught the Python programming language, a language widely considered both powerful as well as easy to use. This course might be considered as a demonstration how bioinformatics improves biologists lives.
The course is designed and aimed for people without computer science background who want to learn programming.
This course is suited for:
Researchers dealing with biological data.
Scientists who would like to learn how to automate everyday tasks and analyse data.
Managers who want to learn how programming improves workflows and conducting projects.
By the end of the course, participants will be able to write short programs, which will allow them to manipulate, analyse and deal with biological data and present results in a graphical format.
Introduction to the Python programming language
Why Python?
Using Python to deal with biological data
Working with the iPython shell
Your first programme
Writing Python scripts
Importing modules
Working with protein and RNA/DNA sequences
Finding motives
Transcription and translation in silico
Handling sequence alignments
Parsing data in different biological formats
Parsing FASTA
Data format conversions
Running biological analyses
BLAST
Accessing biological web services
Dealing with biological 3D structures using Python
Python facilitates statistical analysis
Visualizing data
Creating bar and scatter plots
Calculating an Area Under Curve (AUC)
Working with .xls and .csv files
Importing data from and exporting to MS Excel / OpenOffice Calc
Writing .xls and .csv files
Using Python to create an automated data processing pipeline |
|
wfcsn |
Windows Forms with C#.Net |
35 hours |
Objectives
This course will enable delegates to develop Windows applications using Visual Studio 2005. This includes creating customised forms and controls. It will also cover the C# programming language, using the principles of object orientated programming. Delegates will be able to access data from a database and update this from a Windows form.
Audience
This workshop is intended for software developers who have a desire to learn more about specific technology areas in Windows application development.
Getting started with .Net
What is .Net?
Overview of the framework class libraries
Understanding the Common Language Runtime (CLR)
Compiling an application to a assembly
A tour of the Visual Studio 2005 IDE
C# Language Fundamentals
Data Types
Variables
Constants
Strings
Statements
Expressions
Branching
Conditional branching statements
Unconditional branching statements
Loops
Operators
Assignment
Mathematical operators
Increment & decrement
Relational
Strings
Creating strings
Manipulating strings
The StringBuilder class
Debugging
Setting a breakpoint
Stepping through lines of code
The debugging windows
The call stack
Throwing and Catching Exceptions
The throw statement
The try, catch and finally statements
How the call stack works
Exception class methods and properties
Principle of Object Orientation
Creating models of systems
Classes & objects
Encapsulation, specialisation & polymorphism
Classes and Objects
Defining classes
Creating class constructors
Static and instance members
Destroying objects
Inside Methods
Overloading methods
Encapsulating data with properties
Returning multiple values
Inheritance and Polymorphism
Specialisation and generalisation
Inheritance
Polymorphism
Abstract and sealed classes
The root class: object
Boxing and unboxing types
Interfaces
Implementing and interface
Implementing more than one interface
Casting to an interface
Extending and interface
Delegates and Events
Using delegates
Using events
Generics
Type parameter for classes and methods
Limit generic classes to hold only certain types of data
Generic collections
Building Applications with Windows Forms
Why use windows forms?
Structure of windows forms
Windows forms class hierarchy
Using windows forms
Using controls
New controls in visual studio 2005
Click-once deployment
Customizing Windows Forms and Controls
Methods of authoring controls for windows forms
Windows forms inheritance
Creating the base form
Creating the inherited form
Creating custom controls
Data Access
List the benefits of ADO.NET
Create applications by using ADO.NET
List the main ADO.NET objects and their functions
Use Visual Studio NET data designers and data binding
Explain how XML integrates with ADO.NET
Performing Asynchronous Tasks by Using Multithreaded Techniques
Techniques for asynchronous programming
Load a bitmap into a windows forms application asynchronously.
Using multithreading to perform simultaneous operations
Using the background worker component
Synchronising data between threads
|
|
wfsadm |
WildFly Server Administration |
14 hours |
This course is created for Administrators, Developers or anyone who is interested in managing WildFly Application Server (AKA JBoss Application Server).
This course usually runs on the newest version of the Application Server, but it can be tailored (as a private course) to older versions starting from version 5.1.
Module 1: Installing Core Components
Installing the Java environment
Installing JBoss AS
Application server features
Creating a custom server configuration
Module 2: Customizing JBoss AS Services
How to monitor JBoss AS services
JBoss AS thread pool
Configuring logging services
Configuring the connection to the database
Configuring the transaction service
Module 3. Deploying EJB 3 Session Beans
Developing Enterprise JavaBeans
Configuring the EJB container
Module 4: Deploying a Web Application
Developing web layout
Configuring JBoss Web Server
Module 5: Deploying Applications with JBoss Messaging Service
The new JBoss Messaging system
Developing JMS applications
Advanced JBoss Messaging
Module 6: Managing JBoss AS
Introducing Java Management Extension
JBoss AS Administration Console
Managing applications
Administering resources
|
|
3121 |
Introducing C# 4.0 with Visual Studio 2010 |
28 hours |
IDE
Introduction to Visual Studio 2010
Console.WriteLine, Console.ReadLine
Hello C# World !
Compiling and Debugging
Comments in C #
The mention of Class, using, Main
.NET 4.0
What is .NET?
CLR and GC
DLL and EXE ?
Technologies within. NET
C# Fundamenty
History C# from 1.0 do 4.0
Pascal Case, Camel Case Uppercase
Keywords, Literals, Operators, Punctuators, Statements, Comments
Value Type, Reference Type
Assigning and comparing variables
Conditional operations - If, Switch
Loops - For, Foreach, while, to… while…
Overview of key words and operators of C #
C# 4.0
Numeric and Boolean types
Classes and Objects (inheritance, polymorphism)
Felds
Properties Indexery, Operators
Methods
Delegates, Events, Anonymous Methods
Namespaces
Interface, Structure, Enum
Boards
Exceptions
Generic Types and Anonymous
Strings text strings and characters.
Attributes
.NET Class Library
Collections
Files and Data Streams
Communication between systems
Dates
Serialization
Parallel Programming
Asynchronous operations and parallelized
Useful operations
Access to Data
ADO.NET
LINQ
ORM – Entity Framework
Data in SOA
Review of applications that can be developed in C # and. NET Framework 4
Windows Presentation Foundation
ASP.NET MVC 2
Silverlight
|
|
softeng |
Software Engineering |
35 hours |
Software Engineering starts where programming stops. In this course you will learn a solid foundation in Software Engineering. It builds a bridge from programming to solid engineering practices. The course gives you an overview of basic concepts and vocabulary typically used in the field. During the course, you will learn to use many techniques to plan, implement and validate software projects and to evaluate and improve development processes.
Audience:
This course is intended for software developers with various backgrounds who know at least one programming language.
Day 1: Process
Introduction
What is Systems Engineering?
What is Software Engineering?
Why is Software Engineering difficult?
System requirements
System modeling
Software Engineering Processes
What is a Software Development Process?
Traditional Processes
Agile Processes
Processes for building High-Integrity Systems
Standards & certification systems
High-Integrity Systems
What are High-Integrity Systems?
The role of QM culture
Reasons for errors
Critical systems standard
Reliability engineering
Software Maintenance
Day 2: Planning
Requirements
User requirements
Elicitation/analysis of user requirements
System requirements
Software requirements
Specification of software
Requirements process
Tools to manage requirements
Software Design
Conways Law
Design patterns
Textual modeling tools
Principles of OO design
Design tools
Common architectures
Modeling
Planning an architecture
UML graphical representations
Non-UML graphical representations
Day 3: Code
Software Construction
How to take a design into code
Programming best practices
Abstraction of code
Programming workflow
Configuration Management
What is Configuration Management?
Configuration Management in ISO9000 and CMMI
CASE tools for planning, design & QA
CASE tools for writing software
Version control with SVN
System Integration
Code for High-Integrity Systems
Preventing errors
Catching errors
Reducing the impact of errors
Typical problems with code for High-Integrity Systems
Code quality metrics
Code size metrics
Code complexity metrics
Non-code metrics
Static analysis
Day 4: Verification & Validation
Reviews
Fundamentals of VV
Independent Verification & Validation
Design and requirement reviews
Code inspections
Software Walkthroughs
Audits
Other V & V methods
Testing High-Integrity Systems
Documents regarding safety
Scenarios
Argumentation for safety
Reviews of High-Integrity Systems
Predicting reliability
Formal methods
Costs of V + V
Automated Testing
Why test?
Automatic vs manual tests
Incremental testing
Types of tests
Testing tools
Test Harnesses
Day 5: Management
Project Management
What is Project Management?
Customer handover
Standards (PMP, PRINCE2)
Time management
Cost management
Risk management
Project documentation
Process Evaluation
The function of process evaluation
Acting on the metric
Process metrics
Process evaluation standards & frameworks (CMMI, ISO 9001, TickIt+)
Process evaluation meetings
Summary and Conclusions |
|
cpp11 |
C++ 11 Programming |
14 hours |
This is a 2 day course aimed at C++ programmers who are interested in applying the new C++11 standard in their industry. It is particularly useful for financial applications developers covering all new features with coding examples to be executed within the lab
C++ Standard overview
C++03 Vs C++ 11
Automatic Type Deduction and decltype
Uniform Initialization Syntax
Deleted and Defaulted Functions
nullptr
Delegating Constructors
Rvalue References
C++11 Standard Library
Threading Library
New Smart Pointer Classes
New C++ Algorithms
Object creation in C++11
Move semantic
Variadic templates
Lambda Expressions
C+11 new libraries
Concurrency in C++ 11
|
|
nodejsdev |
Node.js for JavaScript Developers |
21 hours |
Overview
Node.js is a platform for easily building fast, scalable network applications. Learn how to use the event-driven, non-blocking I/O model to build data-intensive real-time applications that run across distributed devices. We will explore the design choices that make Node.js unique, how this changes the way applications are built and how systems of applications work most effectively in this model. Learn how to create modular code that’s robust, expressive and clear. Understand when to use callbacks, event emitters and streams. Use streams to easily manipulate data that would be impossible to fit in application memory. Gain confidence in handling errors effectively to ensure runtime reliability. The course has extensive lab exercises to reinforce the concepts and techniques covered.
Objectives
On completion of this course, students will be able to:
Clearly understand the platform design choices that led to Node.js choosing an event loop and what this means for applications built on that foundation.
Understand the unique trade-offs present in event-driven programming.
Create Node.js modules and express code modularity in an application.
Understand the core flow control patterns in Node.js and know when it is appropriate to use callbacks, event emitters or streams.
Create and manipulate buffers efficiently.
Understand how to manage error state and know when a process should exit due to an error.
Build network applications with Node.js.
Intro to Node.js
RAM vs. I/O latency
Blocking vs. Non-Blocking
Event-driven Programming
Event Loop
Blocking The Event Loop
Node.js Philosophy
Node.js Platform Setup
Download and Install
Node REPL
First Hello World
Modules and npm
Anatomy of a module
Private code
Accessing and using modules
npm commands
package.json
The Callback Pattern
What are callbacks
Callback-last
Error-first
Events
When to use Event Emitters
Binding Functions to Events
Event Requests
Event Listening
Error Handling
Callbacks: Error-first
Errors in Event Emitters
Uncaught Exceptions
Using Domains
Buffers
Why Buffers exist
Creating Buffers
Reading and Writing Buffers
Manipulating Buffers
Streams
What are streams
Read and Write Stream API
Flow Control
Piping
Duplex Stream
Transform Stream
Express.js
Intro and Installing Express.js
Building a Hello Express application
Creating routes
Rendering Layouts
Using templates
Adding partials
Using locals and conditional templates
Modularizing routes
Socket.io
Listening for
Broadcasting
Answering questions
Connecting to Databases
No SQL and Document Stores
Relational DBs
Configuration and platform setup
CRUD Operations
|
|
rust3d |
Rust Language |
21 hours |
# Day 1
- Introduction
- Installation
- rustup
- cargo, rustc
- crates.io
- create a first project
- creating a library or executable
- Cargo.toml
- Cargo.lock
- exploring the source
- cargo tools
- hello world program
- Basic syntax
- functions
- variables
- types
- structs and enums
- control flow: if, loops, pattern matching
- exercise: the guessing game
- Ownership
- moves
- mutability
- borrowing
- lifetimes
- exercise: fixing borrow checker compilation errors
- Modules
- importing code
- visibility
- source code organisation
- Traits and generics
- methods
- generic types, functions and methods
- type aliases
- Standard library
- Option
- Result
- collections: Vec, HashMap
- iterators
- exercise: start building a small in memory database
# Day 2
- Tools
- importing crates
- unit tests
- benchmarks
- fuzzing
- documentation
- attributes
- exercise: integrate unit tests, CI and other tools for the database example
- Strings and slices
- String
- &str
- &[u8]
- Iterators
- Closures
- exercise: start implementing queries
- Destructuring
- if let
- API design
- Usual traits
- Clone and Copy
- Debug and Display
- PartialEq, Eq
- Drop
- Static VS dynamic dispatch
- Associated types
- Deref
- Into
- I/O
- exercise: add optional file storage for the database
- Concurrency
- threads
- channels
- Send, Sync
- mutability
- Arc, Mutex
- exercise: multiple clients querying the database while storing regularly
# Day 3
- FFI
- repr(C)
- exporting functions and structures
- unsafe
- Box
- rusty-cheddar and rust-bindgen
- linking
- cargo-vendor
- exercise: making a C interface for our in memory database
- common libraries and interfaces (adaptable depending on what the students want to focus on)
- docs.rs
- Command
- clap
- serde
- log
- tokio
- rocket
- lazy_static
- nom |
|
unreal |
Unreal Engine 4: Developing 3D games with C++ |
28 hours |
Unreal Engine is an industry-leading suite of game development tools for creating 3D games. It has been used to develop many today's games and series, including Borderlands, Gears of War, BioShock, and Mass Effect.
This training covers the fundamentals of game development with Unreal Engine 4 while giving participants the chance to create their own sample game.
Audience
Beginner game developers
Format of the course
Discussion, hands-on design and development and quizzes
Introduction
Setting up your development environment
Fundamentals of C++ for gaming
Customizing the Unreal UI
Creating your first project
Creating landscapes
Blocking out levels
Assembling a scene
Applying materials and creating special effects
Exporting and importing assets for use in the design
Adding post-processing effects
Crafting a unique look
Unreal's visual scripting language and the Blueprint editor
Creating cinematics
Optimizing performance
Packaging your game for distribution |
|
reactnativeexpo |
React Native Expo: simplifying the creation and deployment of your React Native application |
7 hours |
React Native Expo is a set of tools, libraries and services that acts as an abstraction layer on top of React Native. It simplifies the deployment process, allowing you to generate a build with one click or command without having to create a developer account on various app stores. React Native Expo can be described as Rails for React Native.
In this training, participants learn to use React Native Expo through discussion and hands-on practice. By the end of the course, participants will be equipped to create and deploy their own React Native application using React Native Expo.
For an introductory course on React Native, please see: React Native: Rapidly develop native iOS and Android apps with Javascript
Audience
Web application developers
Format of the course
Part lecture, part discussion, heavy hands-on practice
Introduction
Why Expo?
Overview of Expo SDK
The lifecycle of an Expo project
From start to iOS and Android app
Installation and setup
Creating a new project in Expo XDE
Developing your project locally
Using the asset management system
Handling images, videos, fonts, etc.
Implementing icons, blur views, and more
Wiring up push notifications
Routing and navigation
Publishing your project (non-app store publication)
Publishing your project to App Store and Google Play
Packaging your Expo app into a standalone binary
Detaching your project to the ExpoKit
Making changes to your local project
Viewing logs
Debugging your app
Using an emulator/simulator
Troubleshooting
Removing a published Expo project
Closing remarks |
|
phpopt |
PHP Web Sites Optimization |
7 hours |
This course has been created for PHP programmers and web site developers interested in PHP code optimization.
The course shows how to find a bottleneck and how to refactor or change the code in the appropriate way.
During this course participants will deal with real web page examples, which will be tracked, analysed and optimized.
Stress Testing with JMeter
Identifying what you need to test
Mimicking the real world in JMeter
Extracting and reading the results
Finding Bottlenecks
Introduction to Debuggers
Stack Traces
Function Traces
Code Coverage Analysis
Profiling PHP Scripts
Remote Debugging
Profilers
Use Code Caches, Shared memory and Opcodes
Tuning Opcode
APCu
Alternatives to shared memory
XDebug
Zend Optimizers
Other solutions
Parallel Processing
Ajax
Curl
PHP 7 new features
MySQL Optimization
Finding slow queries
Finding most frequent queries
Caching
Indexing
|
|
mercusr |
Mercurial for Users |
7 hours |
Mercurial and Alternatives Overview
CSV
Subversion
Git
Bazaar
Introduction to Distributed Repositories
Differences between distributed and centralized repositories
Committing, Branching, Tagging
Locking
Mercurial
Mercurial in daily use
Collaborating with other people
Tracking Changes
Merging
File names and pattern matching
Managing releases and branchy development
Finding and fixing mistakes
|
|
androidct |
Cross Train to Android |
35 hours |
A comprehensive course for Java application developers to cross train to Android
Overview
The Android Framework
Dalvik & Linux
Principles
Getting it all up and Running
Eclipse and the ADK
Using the DDMS debugger
Core Android – The Concepts
The Manifest
Widgets
Activities - the basic types
Intents
Services
Content Providers & SQLite
Broadcast Receivers
The Application Context
Essential Internals
Bundles and Intents
The Activity Lifecycle
Notifications
Alarms
The User Interface
What Android has to offer – Widgets & Views in detail
Program vs Declarative
XML – Layouts of all kinds
Styles & Stateful Drawables
AlertDialogs & Menus
The AppWidget
Events and Event Handling
Short Touch and Long Touch
Context Menus
Other Events
Handling Gestures
A First Practical Project
Preferences
Files and Databases
Lists, Adapters and ListViews
Services & Broadcast Receivers
Using Other Apps From Your Own
Threading
The UI thread
Background threads
Async task
Handlers and Loopers - Custom Pipeline Threads
Local Persistence - SQLite in depth
DBHelper
Content Providers
The Android File System
Exception Handling
Custom Exception Handlers
Uncaught Exceptions
Consuming Web Services – SOAP and REST
kSOAP2
rest.org
JSON
XML
Location Based Services
GPS service
Mapping
Phone Location Services
Phone Orientation
Augmented Reality Applications
Graphics
SurfaceView
OpenGL
Graphics2D
Using the Camera
Signature Capture
Media Framework
Audio & Video
Best Practice and Open Source add-ons
Using Custom Base Classes
CommonsWare Additions
Application Deployment - The Market and Signing
|
|
pmsacs |
Programming Metro-style Apps with C# (Windows 8, Windows RT, WinRT) |
21 hours |
Day 1
Understanding WinRT
Pros and cons of HTML5 track over XAML track
Basic form layouts
HTTP communication with JSON
Local data storage
Day 2
More local data storage (ORM)
Infinite scroll lists
Pull to refresh
Multitouch
Split-view
Day 3
Notifications
Location
Social network integration
Selling on Windows Store
Handing in-app purchases
|
|
ddavsvbsqls |
Developing Desktop Applications with Visual Studio 2012, VB.NET and SQL Server 2012 |
21 hours |
This course is divided into 3 main sections and is made up of a mixture of presentations and practical exercises.
VB.NET Language in Visual Studio 2012
VB.NET Object Orientation
VB.NET and Sql Server 2012
Part I. VB.NET Language in Visual Studio 2012
Module 1. Introduction to Visual Basic 2012
The Object-Oriented Programming
The Visual Studio 2012 IDE
Creating a new Application
Using the Help System
Module 2. The Microsoft .NET Framework
The .NET Framework Classes
Executing the Code
Common Language Runtime
Code Loading and Execution
Application Isolation
Security
Interoperability
Exception Handling
Module 3. The Visual Basic 2012 Language
Data Types
Storing Variables
Using Methods
Making Decisions
Working with Data Structures
Using Arrays, Enumerations and Collections
Module 4. Building Windows Applications
Responding to Events
Creating the Toolbar
Creating the Status Bar
Using Multiple Forms
OpenFileDialog and SaveDialog controls
PrintDialog and FolderBrowserDialog controls
Understanding Menu Features
Creating Menus
Context Menus
Part II. VB.NET Object Orientation
Module 5. Building Objects
Understanding Objects
Encapsulation
Methods and Properties
Managing Events
Building Classes
Using Constructors
Managing Inheritance
Module 6. Advanced Language Constructs
Using Lambda Expressions
Using Async and Wait
Using Iterators
Module 7. Exception Handling and Debugging
Handling Exceptions
Try, Catch, Finally
The Throw Keyword
The Exit Try Statement
Using Exit Try Statement
Using Exception Properties
Logging Errors
Module 8. Parallel Programming Using Tasks and Threads
Launching Parallel Tasks
Transforming Sequential Code to Parallel Code
Parallelizing Loops
Specifying the Desired Degree of Parallelism
Creating and Managing Tasks
Part III. VB.NET and Sql Server 2012
Module 9. Database Programming with Sql Server 20012 and ADO.NET
The ADO.NET architecture
The Connection class
The Command and DataReader Classes
The ExecuteReader(), ExecuteScalar(), ExecuteNonQuery() methods
Using Parameterized Commands
Calling Stored Procedure
Managing Transactions
Module 10. Data Components and the DataSet
Building a Data Access Component
Managing Disconnected Data
The DataSet Class
The DataAdapter Class: Filling a DataSet, working with Multiple Tables and Relationships
The DataView Class
Module 11. Using Data Binding
Basic Data Binding
Data Source Controls
The SqlDataSource
Inserting, Updating, Deleting and Selecting records
|
|
bashp1 |
BASH Programming |
14 hours |
The course answers questions:
How does the shell works?
How to write programs in a shell?
The simplest script
Choosing the shell (magic number #!, Sha-bang)
Calling the script
External and built-in commands
Some special characters
Comment (#)
End of Line (;)
An empty statement (:)
Redirection of input output (>, <, >>)
Redirecting output
Redirection of input
Stream (|)
Start the process in the background (&)
Variables and Parameters
Destruction of variables (unset)
Variable with a null value
Save the result to a variable (backquotes ``)
Parameters request ($ 0, $ #, $ 1, $ 2, $ 3 ...)
Manual shift
Quoting.
Escape character (\)
Regular Expressions
Conditional statements
The if / then
The if / then / else
Nesting if statements
The if / elif
case statement
Operators
Operators and, or (&&, | |)
test command
Completing scrypt
The exit statement
Use the status of completion of the program in a script ($?)
Tests and Operators
Operators text file
Tests the file type
Test file attributes
Comparison operators
Comparing arithmetic using the command if
Integer comparison operators
Comparing strings
Comparing the complex (and, or)
Nesting comparison operators
The assignment operator
Arithmetic operators
Operators operations on bits (bitwise operators)
Logical operators
Numeric constants
Loopa
The loop for / in
The command seq
The while loop
Loop until
Controlling the loop (break, continue)
Text Processing
Command head, tail
Sort, Uniq, Expand, Unexpand
Cut, Paste, Join, Wc,Tr
Text search (grep)
Stream Editor (sed)
Interactive programs
Read command
User select
Features
Sleep command
If the script does not work? (debugging) |
|
octaveda |
Octave for Data Analysis |
14 hours |
Audience:
This course is for data scientists and statisticians that have some familiarity statistical methods and would like to use the Octave programming language at work.
The purpose of this course is to give a practical introduction in Octave programming to participants interested in using this programming language at work.
environment
data types:
numeric
string, arrays
matrices
variables
expressions
control flow
functions
exception handling
debugging
input/output
linear algebra
optimization
statistical distributions
regression
plotting
|
|
lnxnetp |
Linux Network Programming |
14 hours |
This course is addressed to junior software developers. After the course completion, the trainees will be able to understand the architecture of well-known web servers such as Apache or Nginx, and implement their own network programs.
The course is 67% lectures, 33% hands-on exercises.
Sockets
Creating datagram sockets
Receiving and sending data
Creating and accepting TCP connections
Closing sockets
Handling errors
Handling more than one client in a simple way
Prefork model, as found in Apache
Forking a new process per client
Cleaning up after finished processes
Threads
Inetd, systemd units
Waiting for data
Blocking sockets
Non-blocking sockets and select
Select as a way to wait for "any of these sockets"
Organizing reads and writes
Dealing with short reads and writes
Reading up to a delimiter
Pipelined requests
Application-level buffers
Event-driven architecture
Using select for multiplexing all client connections in one thread
State machines
Callback hell
Event libraries
"Green" threads
Problem of 10000 connections
Problems with prefork model and select-based loop
poll as an alternative to select
Realtime signals and why you shouldn't use them
Epoll (linux) and kqueue (BSD)
Why and when epoll and kqueue are faster than poll/select
Timeouts and timers
SIGALARM
Timeout as a select argument
A simple case of all-equal timeouts
Priority queue as an abstract data stracture
Binary heap as a priority queue implementation
Timer wheel
timerfd
Integration with the operating system
Traditional daemons
Systemd socket activation
Logging
Handling signals
Performance and scalability optimizations
Choosing the right architecture
Setting socket options
|
|
OMRON_PLC |
Introduction to OMRON PLC programming |
21 hours |
This course introduces the student to the basics of Programmable Logic Controllers (PLC). After the discussion of the fundamental concept of PLCs the basic Ladder Diagram instructions are learned and practiced in Industrial Automation tasks.
Audience
- Electrical Specialists
- Mechanical Engineers
- Programmers with interest in Industrial Automation1. Introduction
- Fundamental concept of PLCs
- Application fields
- Different PLC types
2. Programming OMRON PLCs in Lader Diagram (LAD)
- The programming software
- Hardware setup
- Memory areas
- Basic bitlogic LAD instructions
- Latch circuit
- Controlling pneumatic cylinders with PLC
- Individual exercises |
|
apacheflex |
Getting started with Apache Flex |
14 hours |
Apache Flex is a free, open source framework for building interactive web applications that work across different operating systems, devices, and browsers. In this course, participants will learn how to get started with Apache Flex by building a real-world web application.
Audience
Web developers / web programmers
Designers wishing to become programmers
Format of the course
Course will be hands-on and tasked-based
Introduction
Flex SDK, Flex Builder and Flex Data Services
The MVC framework in Flex
Introduction to MXML and Action script
Creating your first a User Interface (UI)
Setting up your IDE for productivity
Adding controls and containers
Using styles and themes to define your visual design
Handling events in Flex
Understanding event flow
Event handlers and classes
Programming with ActionScript
Object Oriented Programming with ActionScript
Defining and extending classes
Defining and connecting to data services
Sending and retrieving data to and from remote sources
Validating data
Integrating with server backends
Java™, Spring, Hibernate, PHP, Ruby, .NET, Adobe ColdFusion, SAP
Using REST, SOAP, JSON, JMS, and AMF
Testing your application
Working with the automation testing framework
Compiling your application
Compiling MXML (layout) with ActionScript files to output your SWF application
Publishing your application
Taking your application to the desktop with Adobe Integrated Runtime (AIR)
Closing remarks
|
|
unity |
Unity: Developing 3D games with C# and Javascript |
28 hours |
Unity is a cross-platform game engine for developing video games for PC, consoles, mobile devices and websites.
This training covers the fundamentals of game development with Unity while walking participants step-by-step through the creation of their own game.
Audience
Beginner game developers
Format of the course
Discussion, hands-on design and development and quizzes
Introduction
Setting up your development environment
Fundamentals of C# for gaming
Fundamentals of Javascript for gaming
Working with the interface
Manipulating objects
Importing and exporting assets
Setting the scene
Applying physics to the objects in the game
Combining assets to create complex objects
Populating the scene
Implementing behaviors
Developing Boo, JavaScript and C# scripts
Culling
Adding animation
Managing the lighting
Rendering and building the game
Optimizing your game
Packaging your game for distribution |
|
designpat |
Design Patterns |
14 hours |
There are plenty of tried and tested patterns widely available to everyone. Sometimes it is a matter of changing the names and implementing the pattern in a specific technology. It can saves hundreds of hours, which otherwise would be spent on design and testing.
Training Goals
This course has two goals: first, it allows you to reuse widely-known patterns, second, it allows you to create and reuse patterns specific to your organization.
It helps you to estimate how patterns can reduce costs, systematize the design process and generate a code framework based on your patterns.
Audience
Software designers, business analysts, project managers, programmers and developers as well as operational managers and software division managers.
Course Style
The course focuses on use cases and their relationship with a specific pattern. Most of the examples are explained in UML and in simple Java examples (the language can change if the course is booked as a closed course). It guides you through the sources of the patterns as well as showing you how to catalogue and describe patterns which can be reused across your organization.
Introductions
Patterns and tiered architectures
Pattern description
Design patterns and design
Finding and selecting design patterns
Design pattern implementation
Well-known patterns
Object Creation
Factory
Builder
Factory Method
Prototype
Singleton
Structural Patterns
Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy
Behavioural Patterns
Chain of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Template Method
Visitor
Observer
Creating Patterns
To pattern or not to pattern
Formal pattern description
Organizing the pattern catalogue
Particular goal and abstracted goal
Publishing your patterns to a pattern community
|
|
pcvs2012 |
Programming in C# 5.0 with Visual Studio 2012 |
28 hours |
Target group:
Technical Team Leader, Software Developer
Learning objective:
The purpose of training is to understand the syntax of C # and topics related to object-oriented programming in C #.
During the course, students become familiar with the MSDN resources and tools to support the development process, such as Microsoft Visual Studio.
IDE
Introduction to Visual Studio 2012
First program - Hello C# World !
Classes from System.Console namespace
Compilation, Debugging
Comments in C#, Main function, using
Microsoft .NET
What is .NET?
CLR and Garbage Collector
DLL vs. EXE?
Technologies within .NET
Foundations of C#
C# History from 1.0 to 5.0
Pascal Case, Camel Case
Keywords, Literals, Operators, Punctuators
Statements, Comments
Value Type, Reference Type
Assignment vs. variable comparison
Conditional operations - If, Switch
Loops - for, foreach, while, do… while…
Overview of C # keywords and operators
C# 5.0
Namespaces and types
Numerical and Boolean types
Class theory (Encapsulation, Inheritance, Polymorphism)
Fields, Properties, Indexers, Operators
Methods, Delegates, Events, Anonymous Methods
Interfaces, Structures, Enums
Arrays, Collections, Exceptions
Generic and Anonymous types
Strings and chars
Data Flow
Data modelling in C#
Access to databases
LINQ
Entity Framework
CRUD operations
.NET Class Library
Files and Streams
Serialization (binary, text, xml)
Asynchronous operations
Parallel programming
Review of applications that can be developed in C # and .NET Framework 4.5 |
|
subvadv |
Subversion for Advanced Users |
14 hours |
This course is aimed at advanced users of subversion, such as release managers, project leaders, or anyone who wants their svn repository to be in a streamlined production chain, who are involved heavily with branching management, automatic build/compilation and testing, even deployment and updating. The students would benefit from this course working more closely with their development team and deployment team, especially for large size companies or those with geographically distributed branches. This course features a lot of exercises on CentOS 5 virtual machines.
Subversion design philosophy and its advantage
Typical copy-modify-merge scenario, how to solve simple conflicts
Set user policies and guild-line, make team collaboration smooth and consistent
Compensation to copy-modify-merge method (i.e., lock and unlock)
Branching and merging
When to create branches, several usages of branches,
How to resolve conflicts and do merging wisely, how to absorb changes in different directions
How to make use of new features of subversion to do branching and merging
How to encourage or discourage users' local branching
Everyday digest and revision review
Mailing list, RSS, digest
Blaming, delegation
Subversion properties
Built-in properties, properties with SVN: prefixed keywords, global properties
How to design and use these properties
Customized SVN properties for company
Creative usage of customised SVN properties
Disadvantage of SVN properties (i.e., mind the constraints and not to over-engineer it)
Subversion hooks
Hook types
General usage of already shipped hooks
Self-defined hooks
Be creative and imaginative
Secondary SVN server
For backup, fail-safe recovery
For automatic background tasks
For temporary arrangement (i.e., different locations, etc.)
Integration with other tools
Issue tracking systems (i.e., bugzilla, track, Jira, etc.)
Content managing system (i.e., wiki, etc.)
|
|
451 |
Cross-platform mobile development with PhoneGap/Apache Cordova |
21 hours |
The objective of cross-platform frameworks is to allow you to write applications once and have it run on multiple platforms. Want to build an iPhone app that will also run on Android? Have a customer turn round and want their Android app to run on Windows Phone? No problem.
On this three-day PhoneGap/Apache Cordova course you will look at two different yet complimentary technologies for cross-platform mobile development. (Apache Cordova is the new name for PhoneGap. Adobe acquired PhoneGap from the original developers and gifted it to the Apache Software Foundation.)
Upon completion of this PhoneGap/Apache Cordova course, you will be able to build fully-functioning mobile Web applications using the framework, manage source code and handle platform tweaks, create “native like” experiences from a web application -- and much more!
Day 1
Getting up and running
Accessing native capabilities of the device
Structuring source code and handling SCM
Persisting data locally
Building forms and communicating with the server
Day 2
Network communication
Managing source code and handling platform tweaks
Using plug-ins
Working with lists of data
Day 3
Using jQuery Mobile with PhoneGap applications
Presenting Lists of Data
Handling Touch Events
Packaging your apps
|
|
javafunmanven |
Java fundamentals with Maven |
28 hours |
The course covers the basics of Java development and introduces the Apache Maven software project management and comprehension tool.
Getting Started
The Java Technology Phenomenon
How to write basic "hello world" application
How to compile and execute Java code
How to make the code a bit more complex
Introducing Apache Maven
Convention over Configuration
Maven Plugins
Conceptual Model of a Project
Installing and Running Maven
Downloading and Installing Maven
Testing a Maven Installation
Getting Help with Maven
A Simple Maven Project
Creating a Simple Project
Building a Simple Project
Simple Project Object Model
Java Syntax
Object-Oriented Programming Concepts
Variables, arrays, data types, operators, and control flow
What are reference variables
Classes and objects
What inheritance is and how it works
What Interfaces are, why they are written and how
How to use Java String and Number objects and how to format data for output
What packages are for and why we must use import directive
Java Objects
Java classes overview
Java class life cycle
Class modifiers and inheritance
Overloading" and overriding
Class constructors
Polymorphism
Relationships: IS and HAS
'static' keyword
When to use static members
Using objects within an application deployed with Maven
Customizing a Maven Project
Customize Project Information
Add New Dependencies
Add Resources
Building a Packaged Command-Line Application
Optimizing and Refactoring Maven POMs
POM Cleanup
Optimizing Dependencies
Optimizing Plugins
Final POMs
Java Collections
Collection interface
Lists, maps and sets
Collections and arrays
Concurrency
Manage collections with an application deployed with Maven
Java Memory
Garbage collector
Heap and stack
Object life cycle
'finalize()' method
Java Exceptions
The general idea of Java Exceptions
Runtime and 'real' exceptions
Throwing an exception
'try...catch' statements
'throws' declaration
Designing your own exceptions
Test and manage exceptions with an application deployed with Maven
A multimodule project with Maven
Building the Multimodule project
Running the Multimodule application
Java Concurrency
Threads and concurrency
Threaded tasks
Joining threads
Class variables visibility
Build and run a multithread application with Maven
|
|
pcpp |
Programming in C++ |
35 hours |
The course presents a comprehensive object-oriented language C++ and its use of simple examples. These are the standard mechanisms and library
The history and development of C++
Object-oriented programming and procedural
The basic elements of the language C++
Types and declarations
Indicators, arrays, structures
Expressions and Statements
Features
Namespaces
Exceptions
The source files, compile the program
Object-oriented programming - abstraction
Class
Operator overloading
Derived classes
Templates
Handling exceptions
The class hierarchy
Standard libraries
The organization of libraries, containers
Standard containers
Algorithms and Function Objects
Iterators and allocators
Chains
Streams
Figures
|
|
dsguihtml5jsre |
Designing Inteligent User Interface with HTML5, JavaScript and Rule Engines |
21 hours |
Coding interfaces which allow users to get what they want easily is hard. This course guides you how to create effective UI with newest technologies and libraries.
It introduces idea of coding logic in Rule Engines (mostly Nools and PHP Rules) to make it easier to modify and test. After that the courses shows a way of integrating the logic on the front end of the website using JavaScript. Logic coded this way can be reused on the backend.
Writing your rules
Available rule engines
Stating rules in a declarative manner
Extending rules
Create unit tests for the rules
Available test frameworks
Running tests automatically
Creating GUI for the rules
Available frameworks
GUI design principles
Integrating logic with the GUI
Running rules in the browser
Ajax
Decision tables
Create functional tests for the GUI
Available frameworks
Testing against multiple browsers
|
|
python_nltk |
Natural Language Processing with Python |
28 hours |
This course introduces linguists or programmers to NLP in Python. During this course we will mostly use nltk.org (Natural Language Tool Kit), but also we will use other libraries relevant and useful for NLP. At the moment we can conduct this course in Python 2.x or Python 3.x. Examples are in English or Mandarin (普通话). Other languages can be also made available if agreed before booking.Overview of Python packages related to NLP
Introduction to NLP (examples in Python of course)
Simple Text Manipulation
Searching Text
Counting Words
Splitting Texts into Words
Lexical dispersion
Processing complex structures
Representing text in Lists
Indexing Lists
Collocations
Bigrams
Frequency Distributions
Conditionals with Words
Comparing Words (startswith, endswith, islower, isalpha, etc...)
Natural Language Understanding
Word Sense Disambiguation
Pronoun Resolution
Machine translations (statistical, rule based, literal, etc...)
Exercises
NLP in Python in examples
Accessing Text Corpora and Lexical Resources
Common sources for corpora
Conditional Frequency Distributions
Counting Words by Genre
Creating own corpus
Pronouncing Dictionary
Shoebox and Toolbox Lexicons
Senses and Synonyms
Hierarchies
Lexical Relations: Meronyms, Holonyms
Semantic Similarity
Processing Raw Text
Priting
struncating
extracting parts of string
accessing individual charaters
searching, replacing, spliting, joining, indexing, etc...
using regular expressions
detecting word patterns
stemming
tokenization
normalization of text
Word Segmentation (especially in Chinese)
Categorizing and Tagging Words
Tagged Corpora
Tagged Tokens
Part-of-Speech Tagset
Python Dictionaries
Words to Propertieis mapping
Automatic Tagging
Determining the Category of a Word (Morphological, Syntactic, Semantic)
Text Classification (Machine Learning)
Supervised Classification
Sentence Segmentation
Cross Validation
Decision Trees
Extracting Information from Text
Chunking
Chinking
Tags vs Trees
Analyzing Sentence Structure
Context Free Grammar
Parsers
Building Feature Based Grammars
Grammatical Features
Processing Feature Structures
Analyzing the Meaning of Sentences
Semantics and Logic
Propositional Logic
First-Order Logic
Discourse Semantics
Managing Linguistic Data
Data Formats (Lexicon vs Text)
Metadata
|
|
ISAM1 |
ISTQB CTFL |
21 hours |
ISTQB CFTL
70% theory + 30% practice
SW testing fundamentals
Testing throughout the life cycle
Static techniques
Test design techniques
Test management
Tool support for testing |
|
WebAssembly |
Beyond Javascript: build fast, lean websites with WebAssembly |
21 hours |
For the last 20 years, Javascript has been the de-facto standard for in-browser, client-side scripting. WebAssembly represents a new direction. Built into the browser, this binary format will allow developers to compile and execute code written in any language from within the browser. WebAssembly is portable, small and efficient. It enables fast loading times and can run on existing Javascript platforms by translating its binary code to asm.js. More importantly, WebAssembly paves the way for executing newer, more intensive applications such as virtual reality and high-end gaming, to name a few, from within browser.
In this course, we cover the evolution of web programming, the state of things today, and what can be done with the advent and release of WebAssembly. The course will be both explanatory and practical, providing the essential theory and walking participants through the creation of their own WebAssembly program.
Audience
Web developers
C and C++ developers
Format of the course
Course will be hands-on and tasked-based
C and C++ will be used for exercises
Introduction: From Javascript to asm.js to WebAssembly
Antomy of a WebAssembly "program"
Representing byte code with Abstract Syntax Trees (AST)
Writing your first WebAssembly module
Compiling a program to WebAssembly
WebAssembly tooling: Editors, Compilers, and Debuggers
Future applications for WebAssembly
Closing remarks |
|
meteor |
Meteor: Use JavaScript to develop cross-platform mobile applications |
14 hours |
Meteor (aka MeteorJS) is an open-source JavaScript web framework written in Node.js. It integrates with MongoDB and enables rapid prototyping of Android and iOS applications.
This course introduces the fundamentals of Meteor and walks participants through the creation of a real-time web applications for both desktop and mobile platforms.
Audience
Front-end developers
Anyone interested in learning Meteor
Format of the course
Overview of Meteor's features and capabilities along with step-by-step development of a mobile application for iOS and Android.
Introduction to Meteor JavaScript
Installing Meteor
Meteor architecture
Overview of MongoDB
Creating a Meteor application
Meteor's project file structure
Creating a Template and Collections
Working with Forms and Events
Sessions and Trackers in Meteor
Working with the the Core API
Working with HTTP, Email, Assets
Creating a database in Meteor
Building database collections
Sorting the data in Meteor
Building a user accounts system
Creating packages in Meteor
Deploying your application |
|
html |
HTML |
7 hours |
This is a practical workshop which introduces the basic elements of the HyperText Markup Language (HTML).
During the training you will be taught how to determine the structure of using the internet pages.
By the end of this training you will be able to produce a website design which works with well-known packages in this field, e.g., Dreamweaver, MS FrontPage, Microsoft Windows, Unix, Linux, .Net and so on.
Internet and the Web
History of the internet
Methods of Connecting to the internet
Defining terminology which is used
Designs
Restrictions of layouts which can be used
Different screen resolutions
Using the browser and variations
The various ways in which HTML is written
The basics of using HTML exploring the Head and Body sections
Using NotePad, Dreamweaver, SimpleText, HomeSite, etc
File naming
Creating paragraphs and Headings
Using attributes
Formation of text
Special characters and learning how to create line breaks and horizontal rules
Creating Lists
The way to use colour's
The creation of a background colour
Using Colours & text
The Limitations that apply
Hypertext Links
Create Email Links
Anchor links
Links to external sites
Target attributes
Create default colour links
Page to page links
Images
Inserting Images and attributes
File Formats
Using Images as Hyperlinks
Text and Images-aligning
Creation of image maps
Tables
Table - alignment of the content, size, headings
Tables and page layout
Nested tables
Simple text tables
Using Forms
How do forms work using a variation of scripts
Form & elements (Building) - text fields, select menus, radio buttons, checkboxes
Frames
Framesets and using them
Creation of frames and targeting links within framesets
Formatting framesets
Style Sheets
Style Sheets
How to Upload site
Using FTP to publish your site
FTP software (WS_FTP, Fetch, FTP in Dreamweaver)
Testing your site layout
|
|
pamvc5 |
Programming in ASP.NET MVC 5 |
21 hours |
Target group:
Technical Team Leader, Software Developer
Learning objective:
The purpose of training is to acquire the ability to develop business internet applications in ASP.NET MVC 4 technology and in C # language.
During the course, students become familiar with the MSDN resources and tools to support the development process, such as Microsoft Visual Studio.
IDE
Introduction to Visual Studio 2012
First program - Hello ASP.NET MVC World !
Compilation, Debugging, Publish
Microsoft .NET
What is .NET?
CLR and Garbage Collector
DLL vs. EXE?
Technologies within .NET
Foundations of ASP.NET MVC
ASP.NET History
MVC design pattern - description
MVC vs. Web Forms
Differences between MVC 1.0, 2.0, 3.0, 4.0
In and Out
ASP.NET MVC project structure
Resources
URLs and Routing
Controller, Action, View
Filters
POST and GET methods
Data Forms
Data Flow
Data modelling in ASP.NET MVC
Access to databases
LINQ
Entity Framework
CRUD operations
Data Validation
WCF – short introduction to SOA
Advanced topics
IoC (Inverse of Control)
Asynchronous and parallel operations
Unity 2
Complete Business Application - Real World Application
Development of System Architecture in groups based on the specified Business Case
Data modelling
Implementation
Application testing
|
|
jcapsdae |
OpenESB-Java CAPS for developers and architects entry level |
14 hours |
This course is dedicated for technical people who want to learn OpenESB. The training details the technical concepts required for a good understanding of service integration design and development. It covers standard specifications like XML Schemas, WSDL and BPEL used by OpenESB. This 2 day course provides you with the basic knowledge to understand OpenESB principles and designs. For an immediate operational knowledge, OpenESB Training T02 is required.
Basic concepts
Key concepts used for a good understanding of OpenESB
IT Teams constrains
Intermediation principles
Bus Architecture
Contract of services
Encapsulation et Integration
Strong and weak coupling
Orchestration
CAP theorem
Netbeans and Glassfish Introduction
Netbeans introduction and first exercises
Web services creation et Java implementation
JBI Introduction
Bus architecture advantages Components and orchestration
JBI Architecture
Message
NMR
Service Engine
Binding component
JBI management
Service unit
Service Assembly
XML Schemas and WSDL
Basics and advanced concepts used during OpenESB developments
WSDL abstract part
WSDL concrete part
WSDL extension
Partner Links Type
Partner Link
Role
BPEL Basic concepts
OpenESB BPEL engine at a glance
Principles
Activities
Mapper
Graphical editor
BPEL advanced concepts
This chapter covers in detail BPEL activities
Basic Activities
Structured Activities
BPEL proprieties
Compensation
Legacy integration with OpenESB
Integration architecture with OpenESB
Design and Use cases
Mainframe and Legacy systems
Practice
50% of the time will be dedicated to practical works
|
|
mobdevdm |
Mobile Development - An Overview for Decision Makers |
7 hours |
A tour of the technologies which can be used to efficiently target smartphones and tablets users. The pros and cons, the skills required, the business implications.
Audience
This course is intended for decision makers such as company directors, CTO’s, business analysts, project managers, software architects and all the ones who need to understand the implications of a technology choice before committing into one or another.
After completing this course, participants will be able to:
Identify the main actors on the mobile development arena
Understand the major implication of a technology from the user point of view
Understand in broad terms the skills required to develop and maintain each technology
What does mobile application mean?
An overview over the markets
Native vs web vs hybrid application
What are the options available today and the skills/resources needed for each
What is the average cost of a mobile application
What is the average length of a project
A few sample scenarios of business implementations
Questions and answers
|
|
symfewf |
Symfony2 - enterprise web framework |
21 hours |
OOP, common information
OOP paradigm
Decomposition of code
PHP 5.3 and 5.4, new features
Symfony
Short overview
Symfony2 and other framework comparison
Symfony 1.x and 2.x - ne concept
Symfony + Doctrine = enterprise tool
MVC
Twig
Basics of Yaml
Routing
Doctrine ORM
Repository Pattern, Entity Manager, DDD
Testing your code
Creating custom bundles
Security
How to debug your code
Console tools
Dependency management
IoC and DIC
Creating REST API
Silex
Symfony2 and business
Development plan for 2.x
Symfony and enterprise systems
Support and trainings
Community
Framework popularity
Estimating costs of implementing simple CRUD system
Symfony alternatives
|
|
cprog |
Programming in C |
21 hours |
The course is prepared for beginning programmers.
A Brief History of C Programming Language
Basic Instructions
Data types
Keywords
Operators and their priorities
Retrieving and Displaying Data
Printf formatting instructions and scanf
Operators
Functions, macros
Structures
Indicators
Pointers to variables
Pointers to functions
Pointers to variables in the structure
Dynamic memory allocation
Malloc function
Recursion
Functions with a variable number of parameters
unions
bit fields
Basic functions of the library
Libraries math, stdio, stdlib, time
Introduction to algorithms and data structures *
Unidirectional list
Tree
Sorting algorithms
* Optional topics
|
|
mean1 |
Building Web Apps using the MEAN stack |
35 hours |
Course Objective:
MEAN stack is a full-stack JavaScript solution that helps you write scalable, robust, and maintainable web applications quickly and easily using MongoDB, express, AngularJS, and Node.js.
By the end of this hands-on intensive training course, the students will be able to:
Store the data in NoSQL, document-oriented MongoDB database that brings performance and scalability.
Use Node.js, the server-side platform built on Google V8’s runtime for building fast, scalable network applications.
Use Express, a simple yet powerful web application development HTTP server framework built on top of Node.js.
Use AngularJS framework that offers declarative, two-way data binding for web applications.
Take advantage of the ‘full-stack JavaScript’ paradigm i.e. store documents in JSON-like format in MongoDB, author JSON queries in Node.js/Express.js, and forward these JSON documents back to an Angular-based frontend.
Get acquainted with the latest web application development trends in the IT industry.
Node.js
Getting started with Node.js
Node Package Manager
Modules
Asynchronous Programming
Callbacks
Events
Streams
Web Sockets
Angular.js
Angular Architecture
Modules, Controllers and Scope
Views
Two-way Binding
Built-in and Custom Directives
Event Directives
Expressions
Built-in and Custom Filters
Understanding the Digest Loop
Forms and Validation
AngularJS Service Types
Factories, Providers, Decorators, DI
Creating Custom Services
Consuming Ajax Web Services via $http and $resource
Routing, Redirects, and Promises
Express.js
MVC Pattern
Introduction to Express
Routing
HTTP Interaction
Handling Form Data
Handling Query Parameters
Cookies and Sessions
User Authentication
Error Handling
Creating and Consuming RESTful Services
Using Templates
MongoDB
Understanding NoSQL MongoDB
Finding Documents
Update, Insert, and Upsert
Indexing
Data Modeling
Aggregation
|
|
ionic2 |
Ionic2 |
14 hours |
This course introduced IonicShort refresher
HTML5
Javascript
NodeJS
Angular2
mobile hybrid architecture
Ionic2
Single page template
Multi-page template
Tabs components
Ionic API
Theming
SCSS support
third-party integration
Deployment
Release management
Unit testing
User Testing
|
|
technicalarc |
Technical Architecture and Patterns |
21 hours |
With the emergence of very complex distributed systems, complexity of a single system moved to the complexity of the architecture of the group of systems. This course covers the relationship of Software Architecture with Technical Enterprise Architecture. These two areas are interrelated in a way which currently is not well described. For example, splitting complex monolithic system into two systems communicating via web services will trigger substantial changes to both the new systems, and the architecture between them.
This course will cover trade-offs, currently common patterns and solutions for managing complex systems and communication within and between them.
Overview
System and Component Cohesion
System/component Dependencies
Software Architecture
Technical Architecture
Enterprise Architecture
SOA and Micro services architecture
Relationships between above concepts
Logic redudancy vs dependency
Data reduancy vs dependency
Software Architecture
Fundamentals
clarification of terms: architecture, design, modeling
orthogonality
conways Law
Common Architectures
modular decomposition
hierarchical architecture
centralised (Mediator Pattern)
event-based architecture
interrupt-based
OSI
client/server
layer model
Principles of OO Design
DRY, SRP
encapsulation
program against an interface
Liskovs principle
Law of Demeter
Design Patterns
what are Design Patterns
Creational Patterns
Structural Patterns
Behavioural Patterns
Model-Controller-View (MCV)
Design Tools
Domain specific language
Lexical Analysis
CRC cards
scenarios
Use Case descriptions
UML Graphical Representations
Class Diagram
Sequence Diagram
aggregation diagram
UML tools
Non-UML Graphical Representations
ER-modeling
State Machine
data flow
architectural model
Design and Maintenance
Lehmanns Laws
Architectural Antipatterns
Refactoring Strategies
SOA and Integration Patterns
Integration technologies and methods
Synchronous/Asynchronous
More details direct communication patterns
Direct and brokered communication
Message Queuing
ESB
Deployment Patterns
Code Deployment
Immutable deployment
Availability, Scaleability, High Performance, Fault tolerance patterns
Data and messages replication and clustering (CAP theorem)
|
|
typescript |
Typescript |
7 hours |
TypeScript is an open source language for building enterprise Javascript applications. It is a strict superset of JavaScript that compiles to plain Javascript and brings static typing and object-oriented development to the language.
Audience
Web application developers / programmers
Format of the course
This course introduces TypeScript's key features and walks participants through the construction of a real-life JavaScript application.
Introduction
Installing TypeScript
Preparing a TypeScript project
Understanding Typing, Variables, and Functions
Working with Classes and Interfaces
Organizing your code with Namespaces
Reusing code through Modules
Compiling, testing and running TypeScript
Debugging TypeScript
Launching your application
Closing remarks
|
|
resin |
Resin: Setting up a Java Application server for web applications spanning hundreds of servers |
14 hours |
Resin is a fast and reliable open-source Java Application Server for web applications spanning hundreds of servers. Originating as a Servlet and JSP engine, Resin today supports Web Profile, CDI and EJB. Resin includes a high performance JTA transaction manager, a JMS provider, clustering, connection pooling, and a management console. Resin is used by companies such as CNET, Motorola and Salesforce.com.
In this course, we cover the essentials of installing, configuring, securing, optimizing and managing a Resin application server. By the end of the course, participants will have a firm understanding of Resin's architecture, features and capabilities and will have will the practice needed to deploy and manage their own Resin application server.
Audience
System administrators
Enterprise web application developers
DevOps engineeers
Format of the course
Part lecture, part discussion, heavy hands-on practice
Introduction
Installation
Overview of the Resin directory structure
Starting the Resin server
Configuring Resin
Monitoring and administration
Deploying local and distributed applications
Connecting to multiple databases
Using Resin's logging features
Working with the Resin HTTP server
Security: setting up authentication and authorization in Resin
Developing applications with Resin
Testing applications with Resin API for JUnit
Deploying with Resin
Clustering and load balancing your Resin server
Performance tuning for Resin
Closing remarks |
|
subvadmin |
Subversion for Administrators |
7 hours |
This course is for system administrators who need to install and maintain Subversion software and Subversion repository. The aim of this course is to widen the skills of system administrators so that they can administer Subversion repository servers and provide the best advice of the practices of Subversion. This course features a lot of lab exercises on Linux virtual machines.
SVN server setup
install the package and all dependences
to create one repository or several repositories with sensible location considerations, initial import, migrate from CVS and other version control systems
Fine-tune all kinds of access schemes, including http, https, svn, svn+ssh, file, specially to consider following
how to configure Apache modules
to use ssh environment variables to shorten svn+ssh:// urls
to define proper user databases and design complex access control list or authorization patterns
to integrate with LDAP / domain controller / MySQL / PAM / etc for user authentications
Configure sensible repository layout
each sub-project has complete tree structure such as trunk, branches and tags, suitable for sub-projects are inclusive and self-contained, not much inter-dependence, APIs of each sub-projects are stable and mature
all modules exist on trunk / branches and tags, suitable for a logically compact project, there exists strong coupling among modules
difference and benefits
Backup strategy and disaster recovery
backup strategy, including: native method with svn sync, third-party tools such as rsync, hot copy
whole repository backup vs each revision checkout or dump
disaster recovery
permanently remove files and history
Basic knowledge about managing repositories
normal working cycle with subversion (hand-on practices)
create branches and tags
create locks and other controls
design client-side tools and integrate them with IDEs
choose and configure repository viewing facilities
set general user policies, including set subversion hooks for those hard restrictions
design automatic check-out and build or compilation, and even automatic testing
|
|
psl5 |
Programming in Silverlight 5 |
21 hours |
Target group:
Technical Team Leader, Software Developer
Learning objective:
The purpose of training is to acquire the ability to develop business RIA applications in Silverlight 5 technology and in C # language.
During the course, students become familiar with the MSDN resources and tools to support the development process, such as Microsoft Visual Studio.
IDE
Introduction to Visual Studio 2012
First program - Hello Silverlight World !
Compilation, Debugging
Silverlight
What is .NET and what Silverlight?
CLR and Garbage Collector
DLL vs. EXE vs. XAP?
Technologies within .NET
Foundations of Silverlight
Silverlight History
MVVM design pattern - description
Silverlight vs. WPF
Differences between WPF 1.0, 2.0, 3.0, 4.0, 5.0
In and Out
Silverlight project structure
XAML, Layout, Dependency Properties
Commands and Resources
Events
Styles and Behaviours
Databinding, Data Streams
Data Flow
Data modelling in Silverlight
Access to databases
LINQ
Entity Framework
CRUD operations
Data Validation
Controls
Controls review
Silverlight Toolkit
User Controls a Custom Controls
Templates
Advanced topics
Asynchronous and parallel operations, WCF Ria Services
IoC (Inverse of Control)
Unity 2, PRISM
Complete Business Application - Real World Application
Development of System Architecture in groups based on the specified Business Case
Data modelling
Implementation
Application testing
|
|
jcapsdaadv |
OpenESB-Java CAPS for developers and architects advanced level |
14 hours |
This course is dedicated to developers and architects who want to be operational immediately on OpenESB and want to start and be involved on real OpenESB projects. The training scope covers the advanced OpenESB concepts frequently used in projects like correlation and compensation. This 2 day course will allow you to serenely tackle your integration in operational OpenESB projects.
SOA development Process
Introduction to service oriented development process
Fault and exception management in BPEL
Faults and Exception management in BPEL
Faults, exceptions, Catch, Handlers
Advanced concept and exercises
BPEL Compensation
Introduction to compensation in a BPEL process
Advanced concept and exercises
BPEL Correlation
Introduction to Correlation in a BPEL process
Advanced concept and exercises
BPEL mapper advanced Features
BPEL mapper advanced Features (Predicate, Java calls…)
Transaction, Guarantee of delivery, consistency with OpenESB
Advanced lecture on Guarantee of delivery
consistency concept with OpenESB
Exercises
50% of the time is dedicated to practical use cases and exercises
|
|
466 |
Expert Advisor Programming |
7 hours |
An introduction to MQL
Introduction to MetaEditor
Basic Concepts
Layout of an MQ4 File
Order Placement
Bid, Ask and Spread
Order Types
The Order Placements Process
OrderSend()
Calculating Stop Loss and Take Profit
Retrieving Order Information
Closing Orders
A Simple Expert Advisor
Advanced Order Placement
Order Modification
Verifying Stops and Pending Order Prices
Calculating Lot Size
Other Considerations
Putting It All Together
Working with Functions
Add Stop Loss and Take Profit
Using Include Files
Using Libraries
A Simple Expert Advisor (with Functions)
Order Management
The Order Loop
Order Counting
Trailing Stops
Updating the Expert Advisor
Order Conditions and Indicators
Price Data
Indicators
Indicator Constants
Evaluating Trade Conditions
Comparing Indicator Values Across Bars
Working with Time and Date
Datetime Variables
Date and Time Functions
Creating a Simple Timer
Execute on Bar Open
Tips and Tricks
Escape Characters
Using Chart Comments
Check Settings
Demo or Account Limitations
MessageBox()
Email Alerts
Retry on Error
Using Order Comments as an Identifier
Margin Check
Spread Check
Multiple Orders
Global Variables
Check Order Profit
Martingale
Debugging Your Expert Advisor
Custom Indicators and Scripts
Buffers
Creating a Custom Indicator
Scripts
|
|
perltextman |
Text Manipulation using PERL |
21 hours |
This course focuses on text manipulation using regular expressions in PERL. Practical application for text manipulation like processing data files and code files like C and Java will be used. The course will be project oriented where each day ends with creating a small project that parse C files, extract data from comma separated files, generate HTML and XML files
Audience:
Programmer, Developer, Testing personnel, Quality assurance staff who are involved in dealing and generating scripts to control applications
Delivery:
The course will be 50% lectures, 30% labs, 20% project development
Day 1
PERL Programming Language
Text functions in PERL
creating files in PERL
extracting Data from files
Project 1
Day 2
Regular expression basics
Text patterns
Using Regular Expressions in text parsing
Creating a flexible grammar
Project 2
Day 3
code instrumentation using PERL
introduction to HTML
translating text and data into HTML and XML
extracting data from XML and HTML files
Project 3
|
|
pwin8xamlc |
Programming in Windows 8 with XAML and C# |
21 hours |
Target group:
Technical Team Leader, Software Developer
Learning objective:
The purpose of training is to acquire the ability to develop business desktop applications in Windows 8 with XAML and C#.
During the course, students become familiar with the MSDN resources and tools to support the development process, such as Microsoft Visual Studio.
IDE
Introduction to Visual Studio 2012
First program - Hello WPF World !
Compilation, Debugging
Microsoft .NET
What is .NET?
CLR and Garbage Collector
DLL vs. EXE?
Technologies within .NET
Foundations of Windows 8 Development
Windows 8 Development History
MVVM design pattern - description
Windows 8 Development vs. WPF vs. Windows Forms
Differences between XAML with C#, and HTML 5 with JavaScript
In and Out
Windows 8 Development project structure
XAML, Layout, Dependency Properties
Commands and Resources
Events
Styles and Behaviours
Databinding, Data Streams
Data Flow
Data modelling in Windows 8 Development
Access to databases
LINQ
Entity Framework
CRUD operations
Data Validation
Controls
Controls review
User Controls a Custom Controls
Templates
Advanced topics
Asynchronous and parallel operations
IoC (Inverse of Control)
Unity 2, PRISM
Complete Business Application - Real World Application
Development of System Architecture in groups based on the specified Business Case
Data modelling
Implementation
Application testing
|
|
iis8aspadm |
IIS 8 and ASP.NET Administration |
21 hours |
Teaches attendees the fundamentals of administering IIS 8 and applications on the .NET platform.
The course is a mixture of lectures and hands-on exercises. Delegates learn by doing, with immediate opportunities to apply the material they learn to real-world problems.
Introducing the .NET Platform
The .NET Common Language Runtime and Framework Class Library
Review of applications that .NET can be used to create
ASP.NET web forms and web services
ASP.NET web forms versus ASP.NET MVC applications
Classic versus WCF services
IIS 8 Architecture
Integrated Pipeline Mode
Extensibility and Modularity
IIS Manager Extensibility
WAS and the Worker Process
Installing IIS 8
Clean Installation
Upgrade Installation
Adding Features to an Existing Installation
Automated Installation and Configuration
Server Core Command-Line Installation
Hosting Service Recommendations
Administration Tools
IIS Manager and Extensibility
Configuration Settings
Command-Line Management
Command-Line Management with PowerShell
Overview of PowerShell
Getting a list of the IIS 8 PowerShell cmdlets
New cmdlets in IIS 8
Hands-on work with some of the most useful cmdlets
Fundamentals of Web Site Management
Web Sites, Applications, and Virtual Directories
Creating a New Web Site
Configuring Logging
Configuring Host Headers
Administering Applications
Administering Virtual Directories
Configuring Compression
Configuring MIME Settings
Basic Administrative Tasks
Web Application Administration
ASP
ASP.NET
ISAPI
CGI
FastCGI
Application Initialization
Web Application Pool Administration
Understanding Web Application Pools
Virtual Directories versus Applications
Understanding the w3wp.exe Process
Application Pool Security
Advanced Settings
Application Pool Users
Packaging and Deployment
Overview of Options for ASP.NET application deployment
Building an installer package
Handling deployment of updated applications
Versioning applications and managing the deployment of updated applications
Delegating Remote Administration
Introducing the Main Characters
IIS 8 Manager Remote Access
Delegation Settings
Securing IIS 8
Types of Attacks
Securing the Server
Securing IIS 8
Using the Request Filter
Rewriting URLs with the Rewrite module (available as an add-on from iis.net)
Authentication and Authorization
Authentication Types
Configuring the Authentication Types in Use in Your Organization
Understanding IIS 8 User Accounts
SSL and TLS
Securing a Web Site with TLS
Requiring SSL or TLS
Client Certificates
Monitoring and Performance Tuning
How to Monitor IIS 8
IIS Performance Tuning Techniques
Monitoring and tuning your .NET code
Performance tuning suggestions for .NET applications
Diagnostics and Troubleshooting
Common Issues
Runtime Status and Control API
IIS 8 Error Pages
Failed Request Tracing
Error Logging
Access Logging
ASP.NET Tracing
IIS Troubleshooting Strategies
ASP.NET Troubleshooting Strategies
Load Balancing Web Farms
IIS 8 and Web Farms
Content Configuration
Content Replication
Complete Redundancy
Load Balancing
|
|
mlfsas |
Machine Learning Fundamentals with Scala and Apache Spark |
14 hours |
The aim of this course is to provide a basic proficiency in applying Machine Learning methods in practice. Through the use of the Scala programming language and its various libraries, and based on a multitude of practical examples this course teaches how to use the most important building blocks of Machine Learning, how to make data modeling decisions, interpret the outputs of the algorithms and validate the results.
Our goal is to give you the skills to understand and use the most fundamental tools from the Machine Learning toolbox confidently and avoid the common pitfalls of Data Sciences applications.
Introduction to Applied Machine Learning
Statistical learning vs. Machine learning
Iteration and evaluation
Bias-Variance trade-off
Machine Learning with Python
Choice of libraries
Add-on tools
Regression
Linear regression
Generalizations and Nonlinearity
Exercises
Classification
Bayesian refresher
Naive Bayes
Logistic regression
K-Nearest neighbors
Exercises
Cross-validation and Resampling
Cross-validation approaches
Bootstrap
Exercises
Unsupervised Learning
K-means clustering
Examples
Challenges of unsupervised learning and beyond K-means
|
|
azurearchitectures |
Architecting Microsoft Azure Solutions |
14 hours |
This training permits delegates to improve their Microsoft Azure solution design skills. After this training the delegate will understand the features and capabilities of Azure services, to be able to identify trade-offs, and make decisions for designing public and hybrid cloud solutions. During training the appropriate infrastructure and platform solutions to meet the required functional, operational, and deployment requirements through the solution life-cycle will be defined.Module 1: Design Principles for Cloud Infrastructure and Development
Module 2: Designing App Service Web Apps
Module 3: Designing Application Storage & Data Access
Module 4: Securing Resources
Module 5: Design Microsoft Azure Infrastructure and Networking
Module 6: Designing an Advanced Application
Module 7: Designing a Management, Monitoring Strategy
Module 8: Designing a Business Continuity Strategy |
|
advancedcsharp |
Advanced Programming in C# |
35 hours |
C# is an efficient, object-oriented language for developing applications on the Microsoft .NET platform. This course introduces advanced features of C#, examines its usage as both a desktop application programming language and a web programming language for solving real-world problems.
Programming techniques and principals are demonstrated and practiced through in-class hands-on exercises and walk-throughs.
Audience
Developers / programmers
Format of the course
C# advanced principles are discussed as participants step through the creation of a real-world application.
Introduction to advanced programming in C# and .NET
Working with Visual Studio
Windows Forms programming
Multithreading in C#
Handling graphics with GDI+
Attributes, exception handlers and event logging
Fetching type information with Reflection
Dynamic Types
Accessing the file system
Working with Streams, Threads, and Tasks
Asynchronous programming with async and await
Implementing roles-based and code access security
Debugging and compiling your application
C# for creating ASP.NET web applications
Web methods, Web services, and asynchronous Web services
Deploying your application
|
|
dcos |
DC/OS: Turn 1000 machines into a single logical computer |
14 hours |
The Datacenter Operating System (DC/OS) is an open-source distributed operating system built upon the Apache Mesos project. Apache Mesos was built using the same principles as the Linux kernel, only at a different level of abstraction. The Mesos kernel runs on every machine and provides applications such as Hadoop, Spark, Kafka and Elasticsearch with API’s for resource management and scheduling across entire datacenter and cloud environments. Apache Mesos abstracts CPU, memory, storage, and other compute resources away from machines (physical or virtual), enabling fault-tolerant and elastic distributed systems to easily be built and run effectively.
DC/OS brings together Mesos and more than 30 applications into one coherent system, similar to how a Linux distribution packages the Linux kernel with applications to create a working operating system.
This course provides participants with an overview of Apache Mesos and DC/OS and demonstrates through hands-on practice how to deploy and manage a complete Data Center Operating System.
Audience
System administrators
DevOps engineers
Format of the course
Part lecture, part discussion, heavy hands-on practice
Introduction: the need for a datacenter operating system
Resource Sharing
Data Sharing
Programming Abstractions
Debugging and Monitoring
DC/OS's kernel space components
Master and agents
DC/OS's user space components
System components
Admin Router, an internal load balancer
Cosmos, an internal packaging API service
Exhibitor, a Java supervisor system for ZooKeeper
Marathon, an Apache Mesos framework for container orchestration
Mesos-DNS, an internal DNS service
Installing and operating DC/OS
Working with DC/OS components and services
Working with the CLI
Load balancing with Marathon
Installing distributed systems (applications) with DC/OS Universe
HDFS
Apache Spark
Apache Kafka
Apache Cassandra
Jenkins
Deploying applications in Docker containers
Deploying applications in native Mesos containers (using Linux cgroups and namespaces)
Using Marathon for native container orchestration
Ensuring high-availability and fault-tolerance for applications and services
Using the GUI-based monitoring and management system
Scheduling systems such as Kubernetes and Swarm as services
Resource management and abstraction
Exploring other ready-to-install packages
ArangoDB, Avi Networks, Cassandra, Chronos, Confluent, Crate, DataDog, Elasticsearch, Etcd, Exhibitor, HDFS, Hue, Jenkins, Kafka, Linkerd, Marathon-lb, Marathon, MemSQL, mr-redis, Namerd, NGINIX, OpenVPN, Project Calico, Quobyte, Riak, Ruxit, Spark, Spark Notebook, Storm, Swarm, Weave and Zeppelin
Other DC/OS installation options
Bare metal installations vs virtual machines and cloud installations |
|
jsajax |
Javascript And Ajax |
35 hours |
This course has been created for web site developers who want to understand and use Javascript and Ajax.
Browser and Document Objects
When to Use JavaScript
The Document Object Model
When a Document Loads
Object References
Node Terminology
Scripts and HTML Documents
Where Scripts Go into Documents
JavaScript Statements
When Script Statements Execute
Viewing Script Errors
Programming Fundamentals
Variables
Expressions and Evaluation
Data Type Conversions
Operators
Decisions and Loops
Control Structures
Functions
The String Object, Date Object, Array Object
The Regular Expression and RegExp Objects
Control Structures and Exception Handling
Debugging Scripts
Document Object Model Essentials
The Object Model Hierarchy
Object Properties, Methods, Event Handlers
The W3C DOM
Generic HTML Element Objects
Window and Frame Objects
Location and History Objects
The Document and Body Objects
The Form and Related Objects
Button Objects
Text-Related Form Objects
Select, Option and FileUpload Objects
Event Objects
Style Sheet and Style Objects
Functions and Custom Objects
Function Object
Function Application Notes
Creating Your Own Objects with Object-Oriented JavaScript
Object-Oriented Concepts
Creating Ajax Applications
What Can You Do with Ajax?
JavaScript's role
Interacting with Server-Side Code
Passing Data to Server-Side Scripts
Using Ajax with XML
Ajax in Depth
Working with Multiple Concurrent XMLHttpRequest Requests
Handling JavaScript Sent from the Server
Calling Another Domain in Ajax
Working with Ajax and Head Requests
Eliminate Caching
Introducing Ajax Frameworks
Using the Ajax Utility Library
Using libXmlRequest to Download XML
Using AJAXLib to Download XML
Majax, Sack, XHConn, uniAjax Framework
Using Server-Side Ajax Frameworks
XML and Ajax
Retrieving Data from an XML Document
Accessing XML Data Directly and Attributes Values
Validating your XML
Ajax And Security
Protecting Against Malicious Users
Looking at the Security Issues with Proxy Servers
Handling Security in Ajax Applications
Ajax And Web Implementations
Ajax And Validations
Ajax And Dynamic Loading
Ajax And Progress Bars
Ajax And Dynamic Tool tips
Ajax and Web Services
Ajax and Autocomplete
|
|
pwpf45 |
Programming in WPF 4.5 |
21 hours |
Target group:
Technical Team Leader, Software Developer
Learning objective:
The purpose of training is to acquire the ability to develop business desktop applications in WPF 4.5 technology and in C # language.
During the course, students become familiar with the MSDN resources and tools to support the development process, such as Microsoft Visual Studio.
IDE
Introduction to Visual Studio 2012
First program - Hello WPF World !
Compilation, Debugging
Microsoft .NET
What is .NET?
CLR and Garbage Collector
DLL vs. EXE?
Technologies within .NET
Foundations of WPF
WPF History
MVVM design pattern - description
WPF vs. Windows Forms
Differences between WPF 3.0, 3.5, 4.0, 4.5
In and Out
WPF project structure
XAML, Layout, Dependency Properties
Commands and Resources
Events
Styles and Behaviours
Databinding, Data Streams
Data Flow
Data modelling in WPF
Access to databases
LINQ
Entity Framework
CRUD operations
Data Validation
Controls
Controls review
WPF Toolkit Extended
User Controls a Custom Controls
Templates
Advanced topics
Asynchronous and parallel operations
IoC (Inverse of Control)
Unity 2, PRISM
Complete Business Application - Real World Application
Development of System Architecture in groups based on the specified Business Case
Data modelling
Implementation
Application testing
|
|
jcapsdaexp |
OpenESB-Java CAPS for developers and architect expert level |
14 hours |
This advanced training is mainly dedicated to architects and developers working on critical projects where high availability is required. In this course, we will tackle NMR properties and dynamic addressing; you will learn new components like POJO, IEP and advanced features on classical component (ex: File BC). JBI architecture will be reviewed in detail too. In the second part, we will go deeper in Glassfish and OpenESB basic and advanced concepts useful in this kind of environment. Cluster and High Availability best practice will be tackled during the course. Around 60% of the training will be dedicated to practical exercises on Linux and Windows.
OpenESB advanced component
Intelligent Event Process
Plain Object Java Object…
Normalised Message Properties
What are the Normalised Message Properties?
Ex with Http SE, JMS BC, file BC
BPEL dynamic addressing
Introduction to Dynamic addressing
How it works?
How to use it in which context
JBI Architecture
JBI Architecture first approached
Clustering basic concepts
Technical concepts on clustering, high availability
Business process behaviour in multi instance environment
Glassfish Application server in cluster
GF V2.x cluster hierarchy
Domain
Cluster
Instance
Node-agent
OpenESB in a clustered environment
OpenESB constraints in a clustered environment
Components behaviour in a multi instance mode
File BC, JMS BC, HTTP BC, JDBC BC et BPEL SE
Administrative tools
Glassfish console
Asadmin
Practice ex: 1
IEP simple exercise
Practice ex: 2
Dynamic addressing with Http BC
Practice ex: 3
Set up a cluster and OpenESB applications deployment
using the Glassfish admin console
Practice ex: 4
Set up a cluster and OpenESB applications deployment
using Asadmin
Practice ex: 5
JMS Cluster Setting: Embedded and External cluster
|
|
vsvb |
Visual Studio with VB.Net |
21 hours |
Introduction to Visual Studio
This unit provides a hands-on, fast-paced opportunity for experienced developers to learn how to use some of the new productivity features in Visual Studio . It provides an introduction to the use of some language enhancements such as generics, and the use of code snippets. This unit is also designed as an introduction to the workshop learning format.
After completing this unit, students will be able to:
Build collections using generics
Use existing code snippets in code and create new code snippets
Use My classes to access system and application resources
Object-Oriented Design
The following topics are covered in this unit:
Designing Classes
Object-Oriented Programming Concepts
Advanced Object-Oriented Programming Concepts
After completing this unit, you will be able to:
Describe the basics of object-oriented design.
Explain the concepts of encapsulation, inheritance, interfaces, and polymorphism.
Create classes based on use cases.
Model classes for use in .NET by using Visio.
Object-Oriented Programming
The following topics are covered in this unit:
Defining Classes
Creating and Destroying Objects
Inheritance
Interfaces
Working with Classes
After completing this unit, you will be able to:
Define classes.
Instantiate and use objects in client code.
Create classes that use inheritance.
Define interfaces and use polymorphism.
Create shared members.
Create class events and handle them from a client application.
Using ADO.NET
The following topics are covered in this unit:
ADO.NET Overview
.NET Data Providers
The DataSet Object
Data Designers and Data Binding
XML Integration
After completing this unit, you will be able to:
List the benefits of ADO.NET.
Create applications by using ADO.NET.
List the main ADO.NET objects and their functions.
Use Visual Studio .NET data designers and data binding.
Explain how XML integrates with ADO.NET.
Building Data Components in Visual Studio
This unit provides an opportunity for experienced developers to create data access code using new features in Visual Studio .
After completing this unit, students will be able to:
Create data components using Visual Studio
Edit data components using Visual Studio wizards and designers
Write asynchronous ADO.NET code
Consuming and Creating XML Web Services
This unit explains the steps that are necessary to access a Web service from an ASP.NET page and then incorporate that data into the Web application. The new features in Visual Studio related to web services will be discussed.
After completing this unit, students will be able to:
Describe the purpose and process behind calling an XML Web service from a Web Form.
Call an XML Web service directly from a browser by using Hypertext Transfer Protocol (HTTP).
Create a Web reference proxy for an XML Web service Web method and call the method from a Web Form.
Use the templates in Visual Studio .NET to create an XML Web service.
Building Presentation Layer Applications with Windows Forms
This unit provides an opportunity for experienced developers to build rich client applications using the new productivity features in the Visual Studio IDE, and the new controls in the .NET Framework. It also gives students an introduction to the new ClickOnce deployment technology for Windows Forms applications. ClickOnce makes it easy to deploy Windows Forms applications to multiple clients via a Web server, including the ability to automatically update clients when application changes occur.
After completing this unit, students will be able to:
Build Windows Forms applications using Visual Studio
Create databound forms using the RAD databinding features of the IDE
Generate Master-Detail forms using Visual Studio SmartTags
Create databound forms that bind to data components
Deploy a Windows Forms application from a Web server using ClickOnce
Write an application that automatically updates on multiple clients when a new version is deployed
Customizing Windows Forms and Controls
This unit explains how to develop custom Microsoft Windows Forms and controls. Students will learn how to develop user controls, use GDI+ operations, and create new controls that inherit from the Control class. In addition, it demonstrates how to create a nonrectangular Windows Form and how to add features such as attributes and Toolbox bitmaps to controls.
After completing this unit, students will be able to:
Explain the methods of authoring controls for Windows Forms
Draw a user interface by using GDI+.
Create a control that inherits from an existing control.
Create a nonrectangular Windows Form.
Create a custom user control.
Performing Asynchronous Tasks by Using Multithreaded Techniques
This unit demonstrates how to create Microsoft Windows Forms applications that can run tasks in the background. It explains how to make use of the asynchronous methods and other features of components that support the Asynchronous Pattern for Components. Students will also learn how to use the classes in the System.Threading namespace to run one or more tasks in the background by using multiple threads in an application.
After completing this unit, students will be able to:
Explain the concepts and processes that are involved in performing asynchronous programming.
Load a bitmap into a Windows Forms application asynchronously.
Perform multiple simultaneous calculations on a form by using multithreading.
|
|
jsadv |
JavaScript - Advanced Programming |
14 hours |
The training is designed for JavaScript developers, designing and implementing advanced Internet applications. Topics discussed during the training aimed at bringing best practices in JavaScript programming and highlight the most common mistakes. An important point of the training is to discuss the available object-oriented programming with JavaScript syntax.
JavaScript - object orientation
Creating classes and objects
The most important pre-defined objects
Prototyping and constructors
Encapsulation
polymorphism
Inheritance
Aggregation
Design Patterns
Singleton
Factory
Observer
Factory
Decorator
Strategy
Advanced JavaScript programming patterns
Self-timer features
Create an alias objects
Namespaces
module Pattern
Switching Libraries "on demand"
Basics of designing your own library
AJAX
Fundamentals of asynchronous communication
The XMLHttpRequest object
JSON
And server response error handling
JSONP
|
|
2371 |
CICS Command Level Programming |
35 hours |
Topic 1
CICS Concepts
Transactions Concepts and Processing
Topic 2
Intro to CICS programming requirements
How to put data on the terminal screen
Map / Mapsets and how to create them
|
|
eraamauml |
Efficient Requirement Management using Agile Methods and Agile UML Modeling |
21 hours |
Objective:
This training course aims at helping product managers, products owners, business analysts, system architects and developers understand how to efficiently Manage Requirements on the basis of the product vision till guiding developers accurately in implementing them.
More in detail, this course aims at assisting product managers in better defining the value propositions of their products on the basis of strategies and stakeholder needs. Business Analysts and product owners understand how to describe requirements of the product backlog then discover appropriate epics and user stories of the system while contributing to the required value creation. Along interactive case study exercises, participants learn how to describe in detail such requirements in order to validate correct understanding of needs and prepare system acceptance tests. Thus, only using a very common and productive UML profile, they learn to structure requirements in order to communicate efficiently with architects and developers through an iterative requirement gathering process.
Audience:
Product Managers
Product Owners
Business Analysts
Anyone interetsted in the Requirements Management Process
Introduction
What is the Requirement Management Process ? Why Agile ?
Business agility and agile software delivery : Definitions
Linking Agile to Business : Business Motivation Model vs. Business Model Canvas,
How to effciently use the Value Proposition Canvas for defining the Product Vision ?
Business agility vs. agile software delivery principles
What is Agile Not ? Impacts of alignment with strategies and capabilities
Requirement Management in an Agile Context
Scrum Life Cycle : Issues about completeness of requirements and traceability
How productive models enhance communication in 'Agile' ?
Business Extensions of Agile : Structuring Business Value Contribution of a User Story
A Panorama of UML diagrams for modeling requirements
Frameworks for tracing requirements toward software implementation and tests
The 5 levels planning of an agile project (from Clarifying the Vision and Product Backlog to Tasks… and the Architecture Walking Skeleton)
Managing Requirements within Agile Methods (Scrum, DAD) vs. the Unified Process (RUP)
Roles, teams, environments
Presentation of the Case Study for Structuring requirements and managing them using an iterative process
How to describe the business vision and needs via traceable models ?
Qualification of the requirements : The Kano model vs. the Value Proposition Canvas
Structuring the Vision of the Product on the basis of strategies, environmental forces and trends
Value proposition, key activities, key resources, revenue streams and cost structures,
Discovering the business scope of the product using the customer needs, gains and pains
Describing business use cases using 'value streams' and 'value stages'
Bridging the business scope of the product with expected 'value contributions'
Case Study : Describing the vision of the product
How to describe user needs via agile use case modeling (epics and user stories) ?
Agile Estimating and Planning
Building and managing the product backlog / granularity of requirements
Ahead of the sprint planning
Creation of the sprint backlog
Agile User Story Pattern : system scope (the subject), actors, use cases, user stories, acceptance criteria, the INVEST model
The Walking Skeleton using Disciplined Agile Delivery : From Processes to Technology
How to find out epics and user stories on the basis of value streams ?
Value contribution of epics and user stories
Writing tasks : granularity and size using the SMART model
Case Study : Discovering epics and user stories on the basis of value streams
Validating and testing correct understanding of detailed specifications
Using an incremental requirement gathering process and the sprint backlog
Rules for efficient epic, user story and architecture descriptions
Diagrams for validating epics and user story descriptions
How to choose the right diagram ?
Refining features using use cases and relationships modeling
Testing correct understanding of requirements using Test-Driven Requirements
Given/When/Then structures and Operation Contracts for guiding developers in implementing requirements
Coverage analysis and change management
Case Study : Validating, testing and communicating detailed requirements to developers
Conclusion
Steps of efficient requirement gathering and system analysis processes
Traceability between requirements and analysis models
Patterns for gathering and testing requirements
Notice: The above training-mentoring sessions are conducted interactively using examples from Requirement Engineering and Modeling tools in order to ensure good level of traceability between requirements and underlying solutions. Concepts are first explained using basic examples and are then followed by solution drafts to your potential case. After this session, we can also accompany you by reviewing and validating your solutions depending on your needs. |
|
HMIAUTO |
HMI Development for Automotive Infotainment Systems |
14 hours |
This is a specialized HMI Development course designed for automotive professionals who are involved in the development of advanced automotive infotainment system
Introduction to Automotive Infotainment Systems
Overview of different toolchains used to develop Automotive HMI
Overview of Elektrobit EBGuide
EBGuide Workshop
Overview of Fujitsu CGI Studio
Fujitsu CGI Studio-Candera Engine
How to write C++ code for CGI
How to Architect HMI Application
Dbus&GDbus for IPC and Middleware Communication
HMI Application Concurrency Model
C++ ,C++11 Skills needed for Automotive HMI Development
|
|
sysserarch |
Systems and Service Architecture - Microservices Architecture |
14 hours |
Building complex enterprise applications is very challenging in an ever-changing environment.
Changes in the integration between services or systems will trigger changes in the design of the system. This course covers how to design maintainable, fit to the size and purpose of your organisation service and systems architecture and practical infrastructure.
This course covers common problems with building the landscape of distributed apps, starting from integration problem, infrastructure and modern approaches, to solving complexity issues.
This course explains the pros and cons of each solution (e.g. traditional SOA vs Microservice architecture), available tools (mostly open-source) supporting the development and maintenance, etc..
Course Format
It is mostly discussion (with limited presentations).
Quick overview of traditional approaches
Monolithic systems
System of Systems
Early service orientation (EAI, CORBA, etc...)
Early webservices (SOAP, etc...)
Service Oriented Architecture (SOA)
Microservices
Desing concepts and tradesoff
Flexibility and Complexity tradeoff
Cohesion, Coupling
Hidden dependencies vs explicit dependencies
Small system vs Big System
Module/Component vs Service
Generic SOA
Benefit and Costs of SOA
Successes and failures in implementing SOA
Messaging and ESB
Infrastructure and tools supporting SOA
Microservices and implementation of SOA - concepts
Do one thing and do it well
Microservice vs Service
DevOps
Continuous Deployment and Delivery
Lightweight protocols
Microservice protocols and tools
HTTP, JMS, AMQP, Websockets, JSON, etc...
Deployment
Containers (Docker, K8N, LXC, etc...)
Configuration Management (Ansible, etc...)
Monitoring and Management
Infrastructure
Cloud and Auto Scalability
Microservice redundancy and fail-over
Performance scalability
Auto scalability
Implement: OpenStack, AWS, etc....
Real problems
Complexity of ecosystem
Network Performance
Security
Deployment
Testing
Nano-services
|
|
advancedcakephp |
Advanced CakePHP |
21 hours |
This course is designed to help intermediary CakePHP developers access the more advanced features of CakePHP. Through explanations and guided practice, participants will be able to implement better features, stability, security and extensibility into their existing and future CakePHP projects.
Audience
CakePHP developers looking to further their knowledge and development skills
Format of the course
Overview of CakePHP's advanced features together with step-by-step development of a sample application.
Introduction
Model, View, Layer -- beyond the basics
Working with View Templates
Advanced Routing
Authentication and Access Control
Advanced Search and Pagination
Exposing APIs with CakePHP
The Events System
Working with the Shell
Working with MySQL
Working with Javascript
Unit Testing your application
Protecting your application against attacks
Customizing your application's behavior
Styling your CakePHP application with Boostrap
|
|
angular4 |
Angular 4: Create single-page applications using HTML, CSS, and JavaScript |
14 hours |
Angular 4 (previous versions commonly referred to as Angular 2, Angular.js, AngularJS, etc.) is a JavaScript-based open-source front-end web application framework for developing single-page applications.
Angular 4 boasts better performance over its predecessor, more APIs to tap into, and improved support for mobile devices in terms of responsiveness of design and layout.
This course introduces the fundamentals of Angular 4 and walks participants through the creation of a single-page web application.
Audience
Web application developers
Format of the course
Overview of Angular 4's features and capabilities along with step-by-step development of a web application.
Introduction
New features in Angular 4
Overview of ECMAScript 6 (ES6) and TypeScript
Understanding template syntax and forms
Building with Components
Angular 4 services
Building reactivity into your applications
Dependency injection
Loading data via HTTP
Angular 4 modules
Routing in Angular 4
Data flow and state management
Validation directives and pipes
Unit testing
Angular coding and architecture best practices
Conclusion |
|
pythonprog |
Python Programming |
28 hours |
This course is designed for those wishing to learn the Python programming language. The emphasis is on the Python language, the core libraries, as well as on the selection of the best and most useful libraries developed by the Python community. Python drives businesses and is used by scientists all over the world – it is one of the most popular programming languages.
The course can be delivered using Python 2.7.x or 3.x, with practical exercises making use of the full power of both versions of the language. This course can be delivered on any operating system (all flavours of UNIX, including Linux and Mac OS X, as well as Microsoft Windows).
The practical exercises constitute about 70% of the course time, and around 30% are demonstrations and presentations. Discussions and questions can be asked throughout the course.
Note: the training can be tailored to specific needs upon prior request ahead of the proposed course date.
Introduction to Python Programming
Running Python code
Using Python Development Tools (IDEs and command line tools)
Working with Python and iPython shells as well as iPython Notebook
Data Types and Operations
Integers and floats
Strings and bytes
Tuples and lists
Dictionaries and ordered dictionaries
Sets and frozen sets
Organizing and Distributing Code
Creating modules and packages
Distributing code to repositories
Object Oriented and Functional Programming
Creating and using functions and classes
Modifying functions and classes with decorators
Introducing meta-classes
Error Handling and Testing
Handling and raising exceptions
Writing and executing tests (doc tests and unit tests)
Checking code coverage by tests
Working with Files and Directories
Accessing different types of files and file handling principles
Creating, reading, updating and deleting files (including regular text files, csv, as well as Microsoft Word and Microsoft Excel files)
Extracting data from text files using Regular Expressions
Creating and deleting directories, listing and searching for files
Accessing Databases
Selecting, inserting, updating and deleting data
Generic database API based on SQLite 3, PostgreSQL and MySQL
Using the Object Relational Mapper (SQLAlchemy)
Working with NoSQL databases
Conquering The Web
Retrieving web pages
Parsing HTML and XML
Filling web forms automatically
Creating web applications in Python
|
|
dpcs |
Design Patterns in C# |
14 hours |
Target group:
Technical Team Leader, Software Developer
Learning objective:
The purpose of training is to acquire the ability to design advanced development / project structures in C #.
During the course, students become familiar with the MSDN resources and tools to support the development process, such as Microsoft Visual Studio, ReSharper.
Theoretical fundamentals of design patterns
History of design patterns
Design patterns categories
Patterns (theory and practice) - Creational Design Patterns
Abstract Factory
Builder
Factory Method
Object Pool
Prototype
Singleton
Patterns (theory and practice) - Structural Design Patterns
Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Private Class Data
Proxy
Patterns (theory and practice) - Behavioral Design Patterns
Chain of responsibility
Command
Interpreter
Iterator
Mediator
Memento
Null Object
Observer
State
Strategy
Template method
Visitor
Complex Design Patterns
MVC (Model - View - Controller)
Active Record
Repository
Architecture Design Simulation - Hands On Labs
Development of System Architecture in groups based on the specified Business Case
|
|
html5intro |
Introduction to HTML 5 |
14 hours |
Introduction
Background
Audience
Scope
History
Design notes
HTML vs XHTML
Structure of this specification
A quick introduction to HTML
Conformance requirements for authors
Recommended reading
Common infrastructure
Terminology
Conformance requirements
Case-sensitivity and string comparison
UTF-8
Common microsyntaxes
URLs
Fetching resources
Common DOM interfaces
Namespaces
Semantics, structure, and APIs of HTML documents
Documents
Elements
APIs in HTML documents
Interactions with XPath and XSLT
Dynamic markup insertion
The elements of HTML
The root element
Document metadata
Scripting
Sections
Grouping content
Text-level semantics
Edits
Embedded content
Tabular data
Forms
Interactive elements
Links
Common idioms without dedicated elements
Matching HTML elements using selectors
Loading Web pages
Browsing contexts
The Window object
Origin
Session history and navigation
Browsing the Web
Offline Web applications
Web application APIs
Scripting
Base64 utility methods
Timers
User prompts
System state and capabilities: the Navigator object
User interaction
The hidden attribute
Activation
Focus
Assigning keyboard shortcuts
The contenteditable attribute
Spelling and grammar checking
Drag and drop
Editing APIs
The HTML syntax
Writing HTML documents
Parsing HTML documents
Serializing HTML fragments
Parsing HTML fragments
Named character references
The XHTML syntax
Writing XHTML documents
Parsing XHTML documents
Serializing XHTML fragments
Parsing XHTML fragments
Rendering
Introduction
The CSS user agent style sheet and presentational hints
Replaced elements
Bindings
Frames and framesets
Interactive media
Print media
Obsolete features
Obsolete but conforming features
Non-conforming features
Requirements for implementations
IANA considerations
text/html
text/html-sandboxed
application/xhtml+xml
text/cache-manifest
|
|
androiddev |
Android Development |
28 hours |
Objectives:
Upon completion of this training course, the delegate will be able to:
Build their own Android Application and upload it to the Android Market.
Develop for simulators and real devices.
Learn all the basics of Android Development.
Overview of the Android system
Architectural layers and NDK
The Dalvik Virtual Machine
The Android SDK and development tools
Eclipse IDE and ADT
The Android Emulator
Activities, Services, Content Providers, Broadcast Listeners
Using intents and intent filters
Analysis of an Android app
The Android manifest
App permissions
Working with activities and UIs
Views and layouts
Widgets
Event handling
Lists and adapters
Menus and dialogs
Data access and Sqlite
Content providers
Using the sensors on the device
Location-based apps
The Telephony API
Broadcast Receivers
System Broadcasts
Accessing network-based content
Using threads in Android
Developing responsive apps
Publishing to Google Play
|
|
scalaprog |
Programming in Scala |
14 hours |
The training aims to provide opportunities Scala language, learning the syntax of programming paradigms and space applications.
Introduction
What is Scala
The paradigms of object-oriented programming
Functional programming paradigms
Scala and Java
Language runtime environments
Basics of Scala
data Types
Operators
The control instructions and loops
Object-Oriented Programming
Classes
Fields
Methods
Objects and instances
Inheritance, abstraction, encapsulation, polymorphism
Features
Functional Programming
A function declaration
function Arguments
closures
anonymous functions
recursion
delayed initialization
Packages
Packages Scala language
Importing packages
Create your own packages
Other aspects of the Scala language
general types
exceptional service
case of the class.
collections, data structures
parameters alleged
metaprogramming
concurrent programming
|
|
1126 |
Database Version Control (dbv) |
7 hours |
This course show a solution for sharing and versioning your db schema. It contains exercises which cover:
common scenarios in a software development with sharing database changes
using the dbv to debug problems related to database schema changes
dbv.php
Installing
Optional Settings
Pushing schema objects
Receiving schema objects
Creating revisions
Receiving revisions
|
|
oobdp |
Object Oriented Design using Design Patterns |
14 hours |
Objective:
Helping Technical Analysts and Designers to understand how to go through software implementation of the requirements, ensuring traceability between business specifications and the software code.
This 2 day training course aims at assisting technical analysts and designers in designing specifications described by the business analysts. After transformation into software component representations, the resulting system components trace system requirements toward software component structures.
Finally, these technical specifications are implemented in software code and tested upon component basis. The resulting software components provide good level of reactivity to changes as they allow to trace separately toward the implementation level the system behaviours layer by layer (from the user interfaces toward business objects layer through the application components where the usage choices of the actors are stored.
Introduction
What is the System Analysis and Design Process?
Place of the Analysis and Design activities in the Unified Process (RUP)
A panorama of UML 2 diagrams used in the system analysis and design
Frameworks for tracing requirements toward software implementation and tests
How to transform requirements into component based analysis specifications?
Traceability between requirements and system analysis
Advanced notions for representing the system structure and dynamics
Refinement of the requirements on both axis
Toward the system design using operation contracts
Case Study : Definition of the analysis component model of the system
How to transform analysis specifications into design level ones?
Traceability between system analysis and design
Design Patterns for loose coupling and high cohesion of components
Definition of the Design level Architectural Backbone of the system (components, ports, interfaces, exchange objects)
Design level interaction diagrams to implement operation contracts
Case Study : Updating design level component diagram with architectural choices
Implementing technical specifications and testing on a component basis
Generating design level specifications into an object oriented programming language
Deployment of Components on the Physical Nodes
Integration and Acceptance tests on the basis of the previous specifications
Conclusion
Steps of the system analysis and design processes
Patterns for ensuring traceability between requirements and the software code
Testing requirements on the system architecture
Notice: The above training-mentoring sessions are conducted interactively using Requirement Engineering and Modeling tools in order to ensure good level of traceability between requirements and underlying solutions. Concepts are explained first using basic examples and are then followed by solution drafts to your own issues. After this session, we can accompany you by reviewing and validating your solutions depending on your needs. |
|
kotlin |
Programming with Kotlin |
21 hours |
Kotlin is a statically typed programming language for the JVM, Android and the browser.
Audience
This course is directed at programmers and engineers interested in programming with Kotlin.
Getting Started
Basic Syntax
Idioms
Coding Conventions
Basics
Basic Types
Packages
Control Flow
Returns and Jumps
Classes and Objects
Classes and Inheritance
Properties and Fields
Interfaces
Visibility Modifiers
Extensions
Data Classes
Generics
Nested Classes
Enum Classes
Objects
Delegation
Delegated Properties
Functions and Lambdas
Functions
Lambdas
Inline Functions
Other
Destructuring Declarations
Collections
Ranges
Type Checks and Casts
This expressions
Equality
Operator overloading
Null Safety
Exceptions
Annotations
Reflection
Type-Safe Builders
Dynamic Type
Interop
Calling Java from Kotlin
Calling Kotlin from Java
Reference
Documenting Kotlin Code
Using Maven
Using Ant
Using Gradle
Kotlin and OSGi
Tutorials
|
|
smlk |
Simulink® for Automotive System Design |
28 hours |
Objective: This training is meant for software Engineers who are working with MBD technology,the training will cover Modelling techniques for Automotive systems, Automotive standards ,Auto-code generation and Model test harness building and verification
Audience: Software developper for automotive supplierFundamentals & Basics
Using the MATLAB® environment
Essential Mathematics for control systems using MATLAB®
Graphics and Visualization
Programming using MATLAB®
GUI Programming using MATLAB®(optional)
Introduction to Control systems and Mathematical Modeling using MATLAB®
Control Theory using MATLAB®
Introduction to systems modeling using SIMULINK®
Simulink® internals (signals, systems, subsystems, simulation Parameters,…etc)
Stateflow for automotive systems(Automotive Body Controller application)
Introduction to MAAB( Mathworks® Automotive Advisory Board)
Introduction to AUTOSAR
AUTOSAR SWCs modeling using Simulink®
Simulink Tool boxes for Automotive systems
Hydraulic Cylinder Simulation
Introduction to SimDrivelin (Clutch Models ,Gera Models)(Optional)
Modeling ABS (Optional )
Modeling for Automatic Code Generation
Model Verification Techniques |
|
dockerswarm |
Docker with Swarm |
21 hours |
Docker is an open-source platform that automates the building, shipping and running of software applications inside containers.
Swarm is a tool that controls a cluster of Docker hosts and exposes them as a single "virtual" host. By pooling together numerous Docker engines, Swarm allows IT operations teams to transparently scale up their software deployment to many hosts.
Audience
Software developers
System administrator
IT managers and operations teams
Format of the course
After introducing basic software containerization concepts, we discuss how Docker hosts can be deployed across multiple machines using Swarm. Participants carry out live exercises on their workstations to put into practice the concepts learned. By the end of the course, students will be able to deploy Docker with Swarm in a real-life environment.
[DAY 1]
What is Docker?
Docker.com
Docker & Linux Kernel Technologies
Why containers over [x,y,z]?
Docker Essentials
Building Images
Using Registries
Dockerfiles
Running Containers
[DAY 2]
Docker Swarm
Creating a Swarm
Configuring a Swarm
Deploying & Updating Services on Swarm
Docker Swarm for System Administrators
Service Discovery & Load Balancing
Docker Swarm Schedulers
Running Cronjobs on Swarm
Keeping your Swarm Secure
Monitoring
Logging
Shared Volumes
[DAY 3]
Preparing your Infrastructure for Swarm
Provisioning
Partitioning
Networking
Keeping it all secure
Preparing your Application for Swarm
12-Factor Applications: Build Once, Deploy Anywhere
Continuous Delivery to Swarm |
|
BigData_ |
A practical introduction to Data Analysis and Big Data |
28 hours |
Participants who complete this training will gain a practical, real-world understanding of Big Data and its related technologies, methodologies and tools.
Participants will have the opportunity to put this knowledge into practice through hands-on exercises. Group interaction and instructor feedback make up an important component of the class.
The course starts with an introduction to elemental concepts of Big Data, then progresses into the programming languages and methodologies used to perform Data Analysis. Finally, we discuss the tools and infrastructure that enable Big Data storage, Distributed Processing, and Scalability.
Audience
Developers / programmers
IT consultants
Format of the course
Part lecture, part discussion, heavy hands-on practice and implementation, occasional quizing to measure progress.
Introduction to Data Analysis and Big Data
What makes Big Data "big"?
Velocity, Volume, Variety, Veracity (VVVV)
Limits to traditional Data Processing
Distributed Processing
Statistical Analysis
Types of Machine Learning Analysis
Data Visualization
Distributed Processing
MapReduce
Languages used for Data Analysis
R language (crash course)
Python (crash course)
Approaches to Data Analysis
Statistical Analysis
Time Series analysis
Forecasting with Correlation and Regression models
Inferential Statistics (estimating)
Descriptive Statistics in Big Data sets (e.g. calculating mean)
Machine Learning
Supervised vs unsupervised learning
Classification and clustering
Estimating cost of specific methods
Filter
Natural Language Processing
Processing text
Understaing meaning of the text
Automatic text generation
Sentiment/Topic Analysis
Computer Vision
Big Data infrastructure
Data Storage
Relational databases (SQL)
MySQL
Postgres
Oracle
Non-relational databases (NoSQL)
Cassandra
MongoDB
Neo4js
Understanding the nuances: hierarchical, object-oriented, document-oriented, graph-oriented, etc.
Distributed File Systems
HDFS
Search Engines
ElasticSearch
Distributed Processing
Spark
Machine Learning libraries: MLlib
Spark SQL
Scalability
Public cloud
AWS, Google, Aliyun, etc.
Private cloud
OpenStack, Cloud Foundry, etc.
Auto-scalability
Choosing right solution for the problem
|
|
perl |
Perl Programming |
21 hours |
This course gives a comprehensive introduction to Perl programming.
Running Perl programs
Creating a Perl script
Running Perl scripts
Getting help with perldoc
Variable types and contexts
Scalars, lists and hashes
Strings and interpolated strings
Special variables
Context
if/else/elseif
do, while, until, for and foreach
Compound data structures
References to named variables
References to anonymous data
Multidimensional arrays
Multidimensional hashes
Managing files and user input
Standard I/O streams
File handles
Command line arguments
Reading and writing data files
Perl regular expressions
Extracting important text information
Perl regular expressions
Altering data with substitutions
Global and case-insensitive matches
Perl Operators
Arithmetic expressions
Replicating and growing strings
SAssignment operators
ile attributes
Logical operators
Ranges
Subroutines
Defining and calling a subroutine
Passing and receiving parameters
Returning values to the caller
Perl Functions
String functions for text manipulation
List functions
Sorting data
Manipulating file system entries
Reading binary files
split and join
Formatting tabular output
Object Orientation
OO in Perl
Methods, classes and constructors
Obtaining third-party packages from CPAN
How to use use
Defining a schema to employ OO modules
Calling methods with the -> syntax
Passing initialisation parameters
|
|
gitvicsubv |
Git for Victims of Subversion |
7 hours |
This course shows Subversion users how to use Git. It helps to seamlessly migrate habits from SVN to Git and avoid common mistakes.
Everyday Work (in centralized manner)
Committing
Browsing
Tagging and Branching
Merging
Going Remote
Sharing the Work
Git Concepts
Git Objects
Distributed repositories
Authors and Committers
Merging works via e-mail
Merging works from others repositories
Octopus merge
Habits Migration Process
Mirroring Subversion
Working with Git in a centralized manner
Switching to distributed model
Migration process examples (Open Source projects)
Git Plumbing and Advanced topics
Git Commands
Signatures
Ignores and Excludes
Migrating and Bridging
Using Git SVN clone
Working with a Subversion repository and Git working copy
|
|
jqueryadv |
jQuery Advanced |
14 hours |
This course has been created for web developers who want to master jQuery development, develop their own libraries and build a reusable jQuery code.
Javascript and OOP
Chaining
Objects and Prototypes
Optimization
Dynamic properties and methods
jQuery structure and components
Core
Selectors
Attributes
Traversing
Manipulation
Effects
Ajax
XMLHttpRequest object
using HTTP GET, POST
Using JSON objects
jQuery Events
Binding and unbinding events
Convenient event helper methods
jQuery event object
Event features
Event propagation
Plugins
Writing own plugins
|
|
iis7aspadm |
IIS 7 and ASP.NET Administration |
21 hours |
Teaches attendees the fundamentals of administering IIS 7 and applications on the .NET platform.
The course is a mixture of lectures and hands-on exercises. Delegates learn by doing, with immediate opportunities to apply the material they learn to real-world problems.
Introducing the .NET Platform
The .NET Common Language Runtime and Framework Class Library
Review of applications that .NET can be used to create
ASP.NET web forms and web services
ASP.NET web forms versus ASP.NET MVC applications
Classic versus WCF services
Introduction and IIS 7 Architecture
Integrated Pipeline Mode
Extensibility and Modularity
IIS Manager Extensibility
Metabase (gone!)
WAS and the Worker Process
Installing IIS 7
Clean Installation
Upgrade Installation
Adding Features to an Existing Installation
Automated Installation and Configuration
Server Core Command-Line Installation
Hosting Service Recommendations
Administration
IIS Manager
IIS Manager Extensibility
Configuration Settings (walking tour)
Using the Configuration Editor (add-on for IIS 7.0; standard in IIS 7.5)
Command-Line Management
Command-Line Management with PowerShell
Overview of PowerShell
Getting a list of the IIS 7/7.5 PowerShell cmdlets
New cmdlets in IIS 7.5
Hands-on work with some of the most useful cmdlets
Fundamentals of Web Site Management
Web Sites, Applications, and Virtual Directories
Creating a New Web Site
Configuring Logging
Configuring Host Headers
Administering Applications
Administering Virtual Directories
Configuring Compression
Configuring MIME Settings
Basic Administrative Tasks
Web Application Administration [only sections relevant to your environment would be covered]
ASP
ASP.NET
ISAPI
CGI
FastCGI (including the FastCGI interface available as an add-on in IIS 7.0 or standard in IIS 7.5)
Web Application Pool Administration
Understanding Web Application Pools
Virtual Directories versus Applications
Understanding the w3wp.exe Process
Application Pool Security
Advanced Settings
Application Pool Users
Packaging and Deployment
Overview of Options for ASP.NET application deployment
ClickOnce
Building an installer package
Handling deployment of updated applications
Versioning applications and managing the deployment of updated applications
Delegating Remote Administration
Introducing the Main Characters
IIS 7 Manager Remote Access
Delegation Settings
Securing IIS 7
Types of Attacks
Securing the Server
Securing IIS 7
Using the Request Filter (configuration GUI is an add-on in IIS 7.0; standard in IIS 7.5)
Rewriting URLs with the Rewrite module (available as an add-on from iis.net)
Authentication and Authorization
Authentication Types
Configuring the Authentication Types in Use in Your Organization
Understanding IIS 7 User Accounts
SSL and TLS
Securing a Web Site with TLS
Requiring SSL or TLS
Client Certificates
Monitoring and Performance Tuning
How to Monitor IIS 7
IIS Performance Tuning Techniques
Monitoring and tuning your .NET code
Performance tuning suggestions for .NET applications
Diagnostics and Troubleshooting
Common Issues
Runtime Status and Control API
IIS 7 Error Pages
Failed Request Tracing
Error Logging
Access Logging
ASP.NET Tracing
IIS Troubleshooting Strategies
ASP.NET Troubleshooting Strategies
Log4net and other approaches for systematically integrating logging into your applications
Using Additional IIS 7 Built-In Tools
Using Installable IIS 7 tools
Configuring and Load Balancing Web Farms
IIS 7 and Web Farms
Content Configuration
Content Replication
Complete Redundancy
Load Balancing
Other Considerations
Looking Ahead to IIS 8 |
|
3627 |
Introduction to Programming |
35 hours |
The purpose of the training is to provide a basis for programming from the ground up to the general syntax of programming paradigms. The training is supported by examples based on programming languages such as C, Java, Python, Scala, C #, Closure and JavaScript. During the training, participants gain a general understanding of both the programming patterns, best practices, commonly used design and review of the implementation of these topics through various platforms. Each of the issues discussed during the course are illustrated with examples of both the most basic and more advanced and based on real problems.
Introduction
What is programming and why should devote his attention
History of programming
Opportunity to automate tasks using the software
The role of the programmer and the computer in the enterprise
Programming today the development of the current market trends
Declarative and imperative programming. How or What?
Turing machine
Consolidation, compilation and interpretation "on the fly".
Reminder issues of logic and Boolean algebra
predicates
logical sentences
tautologies
Boolean algebra
The first program
structurally
functionally
object
And how else?
Simple types
Representation of strings
Integers
Floating-point numbers
Boolean
Type Null
A blank or Uninitialized
Strong and weak typing
Data structures
Concepts FIFO and FILO
Stacks
Queues
Declaring arrays and lists
Indexing
Maps
Records
Trees
Operators
Assignment Operators.
Arithmetic operators.
comparison Operators
And a comparison of the values in different languages
Bitwise
Concatenation
Increment and decrement operators
The most common errors
Controlling the program
The if, if else instructions
Goto instructions, discuss the problems of application.
The switch
The for loop, for-in
The while loop, do-while
foreach loop
Stopping loop
Creating a reusable code
Functional Programming
Object-Oriented Programming
Functional programming paradigms
What is the function of
Function and procedure
Fundamentals of lambda calculus
Function Arguments
Returning values
Functions as arguments
Anonymous functions
Closures
Recursion
The paradigms of object-oriented programming
Representation of entities from the real world entities in philosophy, ontology
Deciding what you want to object, or other types of
Declaration of classes
Creating instances of classes
Fields, a state of the object
Methods, as the behavior of an object
abstraction
Encapsulation
Inheritance
polymorphism
Association and aggregation
Delegation and separation of relationships between objects
Modules, packages and libraries
Sharing API
The modeling of the system as classes and objects
Describing and programming relationships between classes
Program from a business perspective
Good programming practice
Pitfalls and common errors
High-level code in the interpretation of low-level
Code optimization
KISS principle
DRY principle
Principle Worse is Better
Separation abstraction of implementation
Methods of error detection logic programs
Conventions godowania
Commenting the code
Software Metrics
Overview of these technologies and languages
The area of application of these languages
The main features of language
Prospects for development
The future direction of development: algorithmic, optimization of code, implementing patterns, design patterns, architectural patterns, analytical standards
Reduction of the control structure - the use of artificial intelligence and automated decision-making
Which platform to choose? Individual consultations
|
|
junit |
Unit Testing with JUnit |
21 hours |
JUnit jumpstart
Proving it works
Starting from scratch
Understanding unit testing frameworks
Setting up JUnit
Testing with JUnit
Exploring JUnit
Exploring core JUnit
Launching tests with test runners
Composing tests with TestSuite
Collecting parameters with TestResult
Observing results with TestListener
Working with TestCase
Stepping through TestCalculator
Sampling JUnit
Introducing the controller component
Let's test it!
Testing exception-handling
Setting up a project for testing
Examining software tests
Why we need unit tests
Kinds of tests
Determining how good tests are
Test-driven development
Automating JUnit
A day in the life
Running tests from Ant
Running tests from Maven
Running tests from Eclipse
Coarse-grained testing with stubs
Introducing Stubs
Practicing on an HTTP Connection sample
Stubbing the web server's resources
Stubbing the connection
Testing in isolation with mock objects
Introducing mock objects
Mock tasting's simple example
Using mock objects as a refactoring technique
Practicing on a HTTP connection sample
Using mocks as Trojan horses
Deciding when to use mock objects
In-container testing with Cactus
The problem with unit-testing components
Testing components using mock objects
Integration unit tests
Introducing Cactus
Testing components using Cactus
How Cactus works
Unit-testing servlets and filters
Presenting the Administration application
Writing servlet tests with Cactus
Testing servlets with mock objects
Writing filter tests with Cactus
When to use Cactus, and when to use mock objects
Unit-testing JSPs and taglibs
Revisiting the Administration application
JSP unit testing
Unit-testing a JSP in isolation with Cactus
Unit-testing taglibs with Cactus
Unit-testing taglibs with mock objects
When to use mock objects, and when to use Cactus
Unit-testing database applications
Database unit testing
Testing business logic in isolation from the database
Testing persistence code in isolation from the database
Writing database integration unit tests
Running the Cactus test using Ant
Tuning for build performance
Overall database unit-testing strategy
Unit-testing EJBs
Defining a sample EJB application
Using a fa?ade strategy
Unit testing JNDI code using mock objects
Unit-testing session beans
Using mock objects to test message-driven beans
Using mock objects to test entity beans
Choosing the right mock object strategy
Using integration unit tests
Using JUnit and remote calls
Using Cactus
|
|
sysengsysmluml2 |
System Engineering using SysML and UML 2 |
21 hours |
Objective:
Helping Analysts and Designers of the System Engineering domain to understand how to efficiently gather requirements then go through the embedded software design implementation on the basis of system specifications using UML 2 and SysML.
This 3 days training aims at assisting system analysts to express efficiently their needs and designers to make the appropriate architectural design of the system on the basis of these needs.
The resulting system architecture provides a good level of agility to the embedded system software in face of changes as it allows a coherent traceability of the business rules encapsulated in system functions and those of the usage choices (use cases) of the end-users toward the software implementation level.
Introduction
The System Development Life Cycle with the Harmony Process (IBM/Telelogic)
Overview of the UML/SysML diagrams used in requirements gathering, system analysis and design of the System Engineering domain
A Method based Framework for requirement gathering, system analysis and design
Gathering Requirements and Transforming them into System Specifications
Making business and system requirements traceable using the SysML requirement diagram
Define the scope of the system composed of functions and use cases that invoke these functions
Model the Life Cycle of the System that orchestrates transitions between its states where functions are triggered
Prepare test cases using scenarios that realize Use Cases and System Functions
Case Study : Model the System Scope and the usage of the system functions on the basis of requirements
Transforming System Specifications into Design Level Components
Model the Block Diagram of the system and refine it using internal blocks
Elaborate the Communication Architecture between Sub-System using Parts, Ports and Interfaces
Case Study : Elaborate the block and Internal Block diagrams on the basis of system specifications and by considering design level choices
Model the description of white box Interactions at the design level
Case Study : Model interactions between blocks and Internal Blocks on the basis of design level choices
Mapping of Operations on the Components (Parts) of Blocks
Elaborate the Parametric Diagram of the System Functions
Case Study : Update the Block and Internal Block Diagrams on the basis of design level scenarios
Conclusion
Steps of requirement analysis and system specifications in system engineering
Traceability between requirements and the software
System Integration and Acceptance Tests of the requirements
Notice: The above training-mentoring sessions are conducted interactively using Requirement Engineering and Modeling tools like Enterprise Architect (EA) in order to ensure good level of traceability between requirements and underlying solutions. Concepts are explained first using basic examples and are then followed by solution drafts to your own problems. After this session, we can accompany you by reviewing and validating your solutions depending on your needs. |
|
nodejspm2web |
Node.js Working with PM2 & WebStorm |
14 hours |
Objectives
This course has been created with the following objectives:
Explore and apprehend all the features and functionalities of the webstorm platform for Node.js
Explore and apprehend all the features and functionalities of the pm2 production process manager
Explore and apprehend logging with Winston.js
Audience
The typical attendee for this course include project manager, analyst, developer or any profile that needs
To have a good understanding of an application’s structure and deployment mechanisms
To carry out Installation / production environment / architecture tasks and configuration
To be able to assess code quality, perform debugging, monitoring
To implement advanced production like Logging
Delivery
This course is a mixture of presentations and hands on practice. Most of the concepts are discovered through code readings, exercises and labs.
WebStorm
Getting started
Smart Features
Package Managers
WebStrom & Node, Angular, Express
Code inspection, quality tools, profiling
Debugging
Unit testing
PM2
Application packaging and deployments
Nodejs+pm2 runtime packaging and deployment
Nodejs scripts package
Checking and switching nodejs version
Filesystem locations and standards
Logging
Init scripts
SSL/TLS certificates
Monitoring
Stop, start, delete, resurrect applications
Stop, start, resurrect PM2 process
Logging with Winston.js
Logging with winston
Transports
Loggers
Log levels
Profiling
Streaming logs
Querying logs
Filters, Rewriters
|
|
CCQUANT |
C++ for Modeling Quantitative Finance |
49 hours |
Deep C++ training to cover quantitative methods modeling and introduce a huge project for the trainees to have real hands-on experience with C++ for Quants
Module 1(C++ Phase 1)
Intro + References
Basics
Workshop Basics
Overloading
What can we overload, and how.
Extra C++ Types (bool & reference)
Workshop overloading
OOP
Quick introduction to Oop
Classes
Structs
Access Modifiers
Constructor
default/delete functions
initializer syntax / constructor initialization list
Workshop classes
Memory
Classical memory interaction
Workshop Memory
Module 2
Introduction to quantitative finance
Discrete Time Models
Continuous Time Models
Interest rate models
Options on bonds
Short rate Models
Forward Rate Models
Market Models
Module3 (C++ Phase2 & Quantitative final phase)
Inheritance
Construction
Polymorphism
Virtual, pure virtual, abstract, interface
Access modifiers
Workshop Inheritance (Shapes)
Exceptions
What are they
How do they work
What to throw and what to catch
Workshop exceptions
Memory exhaustion
How it’s notified
How to handle
Modern Memory Management
RAII
Templates applied to Modern Memory Management (SmartPointer)
Standardized C++11 SmartPointers
Nullptr
Workshop SmartPointers
Namespaces
Workshop Namespaces
Vasicek Bond Prices in C++
Black-Scholes Modeling in C++ put &call
Introduction to Monte carlo Simulation
How to price options using Simulation
Monte carlo Simulation in C++
Geometric Brownian Motion
American Vs European Options
Slice based valuation :Lattice Method
Slice based valuation :PDE Method
Slice based valuation :PDE Method
Valuation of American (dates Predetermined) Bermudan Option
Module 4 -C++ Final phase
auto
The new auto keyword
The new auto return syntax
enum
New style enums
constexpr
New constant expressions
About constness
Const and Mutable explained
Lambdas & function objects
Classes that act like functions
Introduction lambda functions
Chrono
An introduction to the new Chrono library
Module 5
Casting
Standard library
String
Containers
Vector (vs)
List
Map
Array
Tuple
Initializer lists
Iterators
range-for syntax
Std Algorithms
Streams
Miscellaneous Keywords
static
explicit
Module 6
Move semantics
Introduction to L/R values
R-value-references applied to move semantics
Type Traits
Obtaining information on compile time
Concurrency
Introduction to C++11’s Threading, async/future and atomic types implementation
Variadic templates - An introduction to C++11’s variadic templates
|
|
ecadpapgeneral |
Embedded C Application Design Principles |
14 hours |
A two day course covering all design principles with code examples coupled with recent industurial technology.
What is design?
Design tools overview
Defining design goals
Software Engineering Challenges
Reusablility
Maintainability
Testability
Configurability
Abstraction
Readability
Redundency-free design
Decomposition
Verbalization
Modularization
Information Hiding
Context-free modules
Loose coupling
Strong cohesion
Acyclic dependencies
|
|
laravel |
Laravel: Build rapid and elegant web applications with the Laravel PHP Framework |
14 hours |
Laravel is an open-source PHP-based MVC (model–view–controller) web development framework. Laravel's features include a modular packaging system with a dedicated dependency manager, different ways for accessing relational databases, utilities that aid in application deployment and maintenance, and syntactic sugar. Laravel has been called the "PHP Framework for Web Artisans"
This course introduces the fundamentals of Laravel and walks participants through the creation of a Laravel-based web application.
Audience
Web application developers
Format of the course
Overview of Laravel's features and capabilities along with step-by-step development of a web application.
Introduction
Overview of Laravel's MVC architecture
Installing and setting up Laravel
Setting up your development environment
Creating a Laravel page
Working with Laravel code
Creating a Laravel application
Routing and Controllers
Handling Requests and Responses
Working with the database
Authenticating users
Laravel services
Testing your Laravel application
Debugging tools and techniques
Deploying your Laravel application
Closing remarks |
|
javaeejboss |
Enterprise Java Programming with Java EE and JBoss (EJB 3.0) |
28 hours |
This 4-day course is for programmers who already know the Java language and wish to exploit the Enterprise Java Beans 2.0 technology while becoming aware of the security implications of distributing applications. This course has a large practical component which includes developing an e-commerce application based on Enterprise Java Beans. The course uses the JBoss Application Server.
Enterprise Java Programming
From client-server to 3-tier architecture
Design considerations
Security considerations
Naming Services
Comparison of RMI, CORBA and EJB
Java Naming and Directory Interface (JNDI)
JNDI Architecture
Service Providers and the Service Provider Interface
The Initial Naming Context
Looking up objects
Creating, searching and destroying directory entries
Exercise 1: JNDI File Search
Introducing Enterprise Java Beans (EJB)
EJB concepts and versions
Component Transaction Monitors
Commercial implementations
The EJB Architecture
Persistence and transactions
Java EE and EJB Deployment
The JEE environment and tools
Configuring Java EE
JEE and JNDI Naming
EJB packaging and deployment
The deployment tool
The Hypersonic Database
Exercise 2: Set up JBoss
EJB Clients
Types of client
Java clients
Web and JSP clients
Servlets and WAR files
Exercise 3: Write and Deploy a Servlet Client
JPA
The role of an JPA
Configuring an JPA
Exercise 4: JPA/li>
Stateless Session Beans
The roles of Session Beans
Creating Session Beans
Stateless Session Beans
Exercise 6: Stateless Session Bean
Stateful Session Beans
Stateful Session Beans
Exercise 7: Stateful Session Bean
EJB Implementation Issues
Meta data
Transaction management
1-1, 1-many, many-1 and many-many associations
EJB versions
The Java Messaging System
The Java Messaging System (JMS)
Exercise 8: JMS
Security
Users and roles
Access control
Authentication
Exercise 9: JBoss Security
Message Driven Beans
The Message Driven Enterprise Bean
Exercise 10: Message Driven Bean
|
|
rmddvcs |
Release Management and Deployment with Distributed Version Control System |
7 hours |
This course has been created for project managers, release managers, product managers, product owners, Scrum Masters, software architects and everyone who is responsible for planning releases and deployment of software.
It shows how to move changes from requirements, through development and tests to production environment using distributed version control system (GIT in particular, but people using other distributed SCMs can benefit from this course as well).
Show overview of Project Management methodologies
Agile Methodologies
Waterfall
Automatic deployment via GIT
Production repository
Release branch
Using Tags for releases
Switching between releases
Managing maintenance release
Major releases
Documentation, Release Change Log
Using Repository History to create Change Log
Using Tag description for major release summarising changes
Aggregating smaller changes into bigger one (closer to the business)
Aggregating commits
Grouping commits into logical parts
Central Repo Push and Pull Strategies
Keeping Central repository clean
Creating structure for aggregating and reviewing changes from developers
Testing and Staging environment
Software Architecture and Components
How to divide logically application and the repository
How to manage libraries and subprojects develop by third parties
Using submodules to automate upgrades
|
|
uwcf |
Understanding Windows Communication Foundation (WCF) |
14 hours |
A two-day instructor-led course to provide participants with the knowledge to understand and help develop distributed applications using WCF 4 and Microsoft Visual Studio 2010. At the end of the course students will have clear indication on how and when to use the various settings and techniques.
Service-Oriented Architecture
SOA - Definition, scenarios and benefits
WCF and SOA
First steps into Windows Communication Foundation
The Service Contract and the Data Contract
The implementation of the Contract
Hosting a WCF service: why and how
How to consume a service
The endpoints
The ABC (Address, Binding, Contract)
Behaviors>
Sharing a contract
Proxy creation through Visual Studio
When and how to use the Channel Factory
Hosting a WCF service
Understanding the role of the host
The available options for hosting (custom vs. commercial) and how to choose
Hosting on IIS, WAS, AppFabric
Long running processes and Windows services hosts
Creating a custom host - why and how
Service host configuration and monitoring
Contracts, endpoints and behaviors
Contract types
The central role of bindings
Why having multiple endpoints
Interoperability
Default endpoints
The communication model
SOAP vs REST
Messaging patterns, how to choose
Instancing and Concurrency, combining the options
The protocols
Understanding the channel stack and the protocols
Reliability
Improve service reliability by using transactions, queues, and reliable messaging
Using routing
Discovery and announcements
How to discover and make services available through WS-Discovery
Testing and troubleshooting
How to individuate errors and how to deal with them
Exceptions vs Faults
Using Fault Contracts
How to write custom error handlers and why
Message logging and tracing
WCF services and security
The holistic view
Authentication and Authorisation
The security model
Transport and Message security
Extending WCF
How and when to extend WCF through behaviors, inspectors and host extensions
|
|
atomjeeadm |
Apache Tomcat and Java EE Administration |
21 hours |
Teaches attendees the fundamentals of administering Apache Tomcat and other Java EE environments.
The course is a mixture of lectures and hands-on exercises. Delegates learn by doing, with immediate opportunities to apply the material they learn to real-world problems.
Introduction to the Java Platform
The JVM, JRE, and JDK
Java SE versus EE
Apache Tomcat as a lightweight servlet/JSP container, and how this differs from full-blown Java EE application servers such as WebLogic, WebSphere, JBoss, and GlassFish
Architecture of Applications installed to Tomcat
Understanding classes versus JARs
Servlets
JSPs
JavaBeans
JNDI and datasources
Resources that your applications may call on other servers (web services, EJBs, etc.)
Installing Tomcat
Installing the Java Runtime Environment (JRE)
Tweaking the JRE for performance
Performing the actual Tomcat installation
Examining the Tomcat installation directories
bin
conf
lib
logs
temp
webapps
work
Configuring Tomcat
server.xml (detailed walkthrough)
web.xml
context.xml
Deploying Java EE Applications
Packaging JARs for deployment to Tomcat
Packaging WARs for deployment to Tomcat
Application server-neutral configuration versus application server-specific configuration
Overview of EARs and other archive types not supported by Tomcat, but supported by other Java EE application servers
Versioning Java EE applications
Managing the deployment of updated applications
Tomcat Valves
AccessLog and FastCommonAccessLog
RequestFilterValve
SingleSignOnValve (by request)
RequestDumperValve (by request)
Memory management and JMX monitoring
Understanding Java garbage collection
Using JAVA_OPTS, JMX and JConsole to monitor and tune Tomcat memory usage
Sizing Tomcat's JVM memory heap
Using JMX and JConsole to configure Tomcat via Tomcat's MBeans
Updating Tomcat's configuration via JMX "on the fly" without restarting Tomcat
Load testing with JMeter
Using VisualVM (new monitoring tool built into JDK 6) and PSI Probe
Controlling JMX MBeans via Ant
Logging and Troubleshooting
JULI logging
log4j logging
Understanding exceptions and thread dumps
Troubleshooting errors that occur in Tomcat
Troubleshooting errors generated by your deployed applications
Troubleshooting strategies applicable to application servers other than tomcat
Connecting databases with Tomcat applications
Classic JDBC approach
Better approach: JNDI resources
Setting up and monitoring database connection pools
Security
File system security
Java security manager
Realms, authentication, and authorization
SSL
Java VM and Tomcat Performance tuning strategies
Additional JVM tuning tips
Enabling parallel garbage collection
Building native connectors
Disabling/removing unneeded applications
Tuning incoming connections and database connection pools
Turning off Jasper development mode
Precompiling JSPs
Preloading servlets
Application-specific tuning suggestions
Tuning levers available in other application servers
The World Beyond Tomcat: Understanding Java EE Applications
Explanation of the Java EE APIs not supported by Tomcat: EJB, JMS, and many others
3rd party application frameworks overview (what they are and what administrators should know): Spring, Struts 1/Struts 2, JSF (including a discussion of ICEfaces, RichFaces, etc.)
Data tier frameworks and what administrators should know (Hibernate, JPA, etc.)
Features offered by WebLogic, WebSphere, and JBoss that are not found in Tomcat
Tomcat Other Features
Memory leak prevention and detection
Servlet 3.0, JSP 2.2, and EL 2.2 support (and the practical implications of this for Tomcat admins)
Cross-site request forgery prevention (and how to configure)
How Tomcat 7's new session management features prevent session fixation attacks
Alias support (which allow static content to be stored outside the WAR file)
Running Tomcat behind Apache httpd or IIS [this section would be taught using your web server and connector module of choice]
Why run Tomcat behind Apache httpd or IIS?
Installing mod_jk (Apache or Tomcat) or mod_proxy_ajp and mod_proxy_balancer (Apache 2.2 or later only)
Proxying traffic to Tomcat via AJP
Monitoring the status of your web server's connection to Tomcat
Load balancing Tomcat via mod_jk or mod_proxy_balancer
Tomcat Clustering
Configuring mod_jk (in Apache or IIS) or mod_proxy_balancer (Apache 2.2 or later only) as a load balancer
Hardware load balancing as an alternative to software load balancing
Sticky sessions
Configuring a shared session back-end
FileStore/JDBCStore (older approach, generally not recommended)
Using the <Cluster> tag
Configuring the application to be distributable
Setting up and testing failover
|
|
qaci |
Quality Assurance and Continuous Integration |
14 hours |
Training is open to both developers, Scrum Masters, Product Owner and also some aspects of the business department. The purpose of training is to introduce topics Quality Assurance and Continuous Integration and their place in projects conducted agile methodologies. Participants will gain a broad perspective on the issues discussed as well as practical knowledge of the tools and processes of software development in line with the QA / CI. Representatives of business, will be able to know the benefits of implementing those tools and processes and translate into both the time and cost of software development. The issues presented are based on PHP or Java, depending on customer requirements.
QA/CI
What is QA?
What is CI?
The costs of software development, refactoring and fix errors
Identifying and understanding the project
Profit for the organization
DDD
Software development based on business requirements, assumptions DDD
Problems in communication IT-Business
Domain Model
Best Practices
KISS principle and DRY
Coding standards
Creating reusable code through OOP and design patterns
Identifying and reducing cyclomatic complexity
Software Metrics
Weight Method per Class
Response For a Class
Depth of Inheritance Tree
Coupling Between Objects
Lack of Cohesion of Methods
Number of Children
Cyclomatic complexity
Metrics class
Model Metrics
Metrics for use
Software Testing
What, when and how to test?
The method of "white-box" and "black box"
The role of testing in agile methodologies
TDD only a potential increase in the cost of the project
Unit testing with JUnit (Java), PHPUnit (PHP)
Behavioral tests of JBehave (Java), Behat and Mink (PHP)
Functional tests
Refactoring
What is refactoring?
Debt technology
Code smell
Refactoring patterns
Documentation
The role of documentation in agile methodologies
What to document?
Types of documentation
Documentation and agile methodologies, or you can call (Working software over comprehensive documentation)?
Standard XMI
Automatic generation of documentation from the Javadoc (Java), ApiGen (PHP)
Tools and Environment CI
Tools and Environment CI
PMD (Java), phpmd (PHP)
CPD (Java), phpcpd (PHP)
Lines Of Code Counter (Java), phploc (PHP)
UCDetector (Java), phpdcd (PHP)
Jdepend (Java), phpdepend (PHP)
Jenkins Continuous Integration Server
Agile and CI/QA
Planning and incremental development
Embracing Change
Short stages
Interdisciplinary team
Extreme Programming, Code Review
Individuals and interactions over processes and tools
Summation
Discussion
Questions
How do you begin the process of implementation?
|
|
angjs |
Angular JavaScript |
28 hours |
This is a hands on course is for anyone wanting to create Web sites using AngularJS.
During this course the latest stable version will be used. Pre-release version can be just used if marked in the booking form in remarks section. Older version need to be agreed before booking.
What is Angular JS?
HTML5, CSS and JavaScript
JSON and Ajax
Angular JS Applications
Bootstrap CSS
Models
Bindings
Expressions
Simple expressions
Values
Objects
Arrays
Maps
Directives
Data typing
Looping over arrays and arrays of objects
Creating tables
Enabling and disabling HTML elements
Hiding and showing HTML elements
Handling HTML events
Custom Directives
Controllers
Defining controllers
Object property functions
Controller methods
Controllers in external files
Namespaces
Global namespace
Modules
Module dependencies
Library loading
Where to put scripts
Application files
Filters
Convert to currency
Array subsets
Upper and lower case conversion
Sorting
HTTP Requests
General requests
Shortcuts
Success and error handling
Setting HTTP headers
JSON and XSRF vulnerability protection
Forms
HTML input controls
Browser versus Angular JS validation
Validating input values
Displaying input error messages
Angular Modules
Services
Animation
REST
Cookies
Mobile device support
Single Page Application Concept
Routing in Single Page Application (SPA)
|
|
ios8xcode6devs |
iPhone and iPad Development in Swift for iOS 8 and Xcode 6 |
35 hours |
This 5 day course is for developers who want to learn how to develop applications for iPhone and iPad running iOS8. The course is hands on and shows how to develop applications from scratch using Apple's new Swift programming language using the Xcode6 IDE. During the course a fully functional Tetris style block game will be developed from scratch using Swift. The course ends with developing a new application from scratch in Swift. The course assumes some programming experience.
This course can only be run on Intel based Apple hardware such as a MacBook or a Mac Mini. Delegates need to have registered with Apple and have an Apple ID which is required to download software. Delegates wishing to run the applications developed during the course on an iPhone or iPad need to be registered as iOS developers with Apple and have registered their device for development. Apple charge $99 per year to register as an iOS developer.
Development environment
Development environment requirements
Xcode and the iOS SDK
Apple Developer registration
Reasons why Applications get rejected
Xcode iOS Projects
Human Interface Guidelines
Creating an iOS project
Running on simulator and real devices
Memory management
Strong and weak references
Swift
Swift programming language overview
Using Xcode to develop Swift applications
Scenes
Creating Scenes
Implementing View Controllers
Swift Classes
Creating Swift classes
Instance variables and initialisation
Constructor types
Protocols, Hashable and Printable
Inheritance
Working with Graphics
Adding icons and images
Using the SpriteKit API
Animating sprites
User Interaction
Buttons and handler
Pan gesture recognition
Tap gesture recognition
Case Study
Develop a new application using Swift
Distributing Applications
Moving applications to a device for testing
Getting an application into AppStore
|
|
nodejspm2 |
Node.js and PM2 |
14 hours |
Audience:
Anyone involved in IT Service Delivery and Production Support
application packaging and deployments
nodejs+pm2 runtime packaging and deployment
nodejs scripts package
checking and switching nodejs version
filesystem locations and standards
log rotation
init scripts
SSL/TLS certificates
monitoring
stop, start, delete, resurrect applications
stop, start, resurrect PM2 process
|
|
simulinkadv |
Simulink® for Automotive System Design Advanced Level |
14 hours |
Fundamentals
Using the MATLAB® environment
Essential Mathematics for control systems using MATLAB®
Graphics and Visualization
Programming using MATLAB®
GUI Programming using MATLAB®(optional)
Introduction to Control systems and Mathematical Modeling using MATLAB®
Control Theory using MATLAB®
Introduction to systems modeling using SIMULINK®
Model Driven Development in Automotive
Model Based versus Model-less Development
Test Harness for Automotive Software System Tests
Model in the Loop, Software in the Loop, Hardware in the Loop
Tools for Model Based Development and Testing in Automotive
Matelo Tool Example
Reactis Tool Example
Simulink/Stateflow Models Verifiers and SystemTest Tool Example
Simulink® internals (signals, systems, subsystems, simulation Parameters,…etc)-Examples
Conditionally executed subsystems
Enabled subsystems
Triggered subsystems
Input validation model
Stateflow for automotive systems(Automotive Body Controller application)-Examples
Creating and Simulating a Model
Create a simple Simulink model, simulate it, and analyze the results.
Define the potentiometer system
Explore the Simulink environment interface
Create a Simulink model of the potentiometer system
Simulate the model and analyze results
Modeling Programming Constructs Objective:
Model and simulate basic programming constructs in Simulink
Comparisons and decision statements
Zero crossings
MATLAB Function block
Modeling Discrete Systems Objective:
Model and simulate discrete systems in Simulink.
Define discrete states
Create a model of a PI controller
Model discrete transfer functions and state space systems
Model multirate discrete systems
Modeling Continuous Systems:
Model and simulate continuous systems in Simulink.
Create a model of a throttle system
Define continuous states
Run simulations and analyze results
Model impact dynamics
Solver Selection: Select a solver that is appropriate for a given Simulink model.
Solver behavior
System dynamics
Discontinuities
Algebraic loops
Introduction to MAAB ( Mathworks® Automotive Advisory Board) -Examples
Introduction to AUTOSAR
AUTOSAR SWCs modeling using Simulink®
Simulink Tool boxes for Automotive systems
Hydraulic cylinder Simulation-Examples
Introduction to SimDrivelin (Clutch Models, Gera Models) (Optional) -Examples
Modeling ABS (Optional ) -Examples
Modeling for Automatic Code Generation -Examples
Model Verification Techniques -Examples
Engine Model (Practical Simulink Model)
Anti-Lock Braking System (Practical Simulink Model)
Engagement Model (Practical Simulink Model)
Suspension System (Practical Simulink Model)
Hydraulic Systems (Practical Simulink Model)
Advanced System Models in Simulink with Stateflow Enhancements
Fault-Tolerant Fuel Control System (Practical Simulink Model)
Automatic Transmission Control (Practical Simulink Model)
Electrohydraulic Servo Control (Practical Simulink Model)
Modeling Stick-Slip Friction (Practical Simulink Model)
|
|
Torch |
Torch: Getting started with Machine and Deep Learning |
21 hours |
Torch is an open source machine learning library and a scientific computing framework based on the Lua programming language. It provides a development environment for numerics, machine learning, and computer vision, with a particular emphasis on deep learning and convolutional nets. It is one of the fastest and most flexible frameworks for Machine and Deep Learning and is used by companies such as Facebook, Google, Twitter, NVIDIA, AMD, Intel, and many others.
In this course we cover the principles of Torch, its unique features, and how it can be applied in real-world applications. We step through numerous hands-on exercises all throughout, demonstrating and practicing the concepts learned.
By the end of the course, participants will have a thorough understanding of Torch's underlying features and capabilities as well as its role and contribution within the AI space compared to other frameworks and libraries. Participants will have also received the necessary practice to implement Torch in their own projects.
Audience
Software developers and programmers wishing to enable Machine and Deep Learning within their applications
Format of the course
Overview of Machine and Deep Learning
In-class coding and integration exercises
Test questions sprinkled along the way to check understanding
Introduction to Torch
Like NumPy but with CPU and GPU implementation
Torch's usage in machine learning, computer vision, signal processing, parallel processing, image, video, audio and networking
Installing Torch
Linux, Windows, Mac
Bitmapi and Docker
Installing Torch packages
Using the LuaRocks package manager
Choosing an IDE for Torch
ZeroBrane Studio
Eclipse plugin for Lua
Working with the Lua scripting language and LuaJIT
Lua's integration with C/C++
Lua syntax: datatypes, loops and conditionals, functions, functions, tables, and file i/o.
Object orientation and serialization in Torch
Coding exercise
Loading a dataset in Torch
MNIST
CIFAR-10, CIFAR-100
Imagenet
Machine Learning in Torch
Deep Learning
Manual feature extraction vs convolutional networks
Supervised and Unsupervised Learning
Building a neural network with Torch
N-dimensional arrays
Image analysis with Torch
Image package
The Tensor library
Working with the REPL interpreter
Working with databases
Networking and Torch
GPU support in Torch
Integrating Torch
C, Python, and others
Embedding Torch
iOS and Android
Other frameworks and libraries
Facebook's optimized deep-learning modules and containers
Creating your own package
Testing and debugging
Releasing your application
The future of AI and Torch |
|
DEVOPSJEE |
Fundamentals of Devops for Java Enterprise Edition Projects |
21 hours |
This training course introduces the core DevOps concepts and principles as well as the ways to stand up the DevOps practice in your organization. It is specifically focused on projects on the Java Platform. Upon completion of this training course, students will have a fundamental understanding of DevOps’ value proposition; they will also gain practical experience working with select DevOps tools, including Puppet, Jenkins, Git and others. This training course is supplemented by hands-on labs that help attendees reinforce their theoretical knowledge of the learned material.
Topics:
DevOps practices and tools
Puppet
Technical introduction to cloud computing
Jenkins
1. Introduction
Establish Goals and Current State
The Goal of DevOps
2. What Is DevOps?
Background and History
Symptoms and Problems in Today's Environment
The IT Core Chronic Conflict
DevOps Roles
DevOps Defined
Core Concepts
3. Ball Point Game
4. Why Do DevOps?
Driving Factors
Amazon's Process: A Case Study
State of DevOps Report
Manufacturing and DevOps
5. DevOps at Microsoft – a Case Study
Dark Launches
Feature Flags
Agile to DevOps
Branching
Teams
Live Site Culture
6. How Does DevOps Work
Continuous Integration
Continuous Deployment
Continuous Delivery
Continuous Testing
Continuous Monitoring
Automation
Kanban End-to-End
7. Culture and DevOps
People and Trust
Resilience
Engagement is Key
Change the Metrics!
Law of Motivation
Keys to Successful DevOps Culture
9. Tool Time
Build Automation
Test Automation
Deployment Automation
Git
Environment Provisioning
Automated Feedback and Monitoring
10. DevOps Assessment
12. Summary and Next Steps
In-Class Exercises:
Individual and Team Goals – Identifying current issues and goals
The Ball Point Game – Creative team game to learn about process optimization
The Penny Game – see how Kanban and batch sizes affect delivery
DISC Assessment – personality / culture exercise
DevOps Assessment – Where Are We?
|
|
javaph |
Java Persistence with Hibernate |
14 hours |
This course teaches the practical use of Hibernate for persisting Java objects in a relational database.
Introduction to Hibernate
Introducing Hibernate
The Object/Relational Mapping Problem
JDBC
The Users-Roles Schema
Tools and Environment Setup
Creating the Database
Configuring Hibernate
Hibernate Distributions
Required Libraries
Configuration Files
hibernate.properties
hibernate.cfg.xml
Hibernate Persistence
The Hibernate Architecture
SessionFactory Methods
Hibernate Sessions
Object States
State Transitions
Session Methods
Transactions
Session-Per-Operation
Session-Per-Request
The Data Access Object Pattern
Object/Relational Mapping
Object-Oriented Design
Relational Mapping
Bidirectional Association
O/R Mapping Techniques
The Mapping Document
The Mapping XML Model
Primary Keys and Identity
Generating Identifiers
Other Mapping Elements
Components
Mapping Associations
The Mapping XML Model for Associations
Unidirectional Many-to-One
Eager Fetching
Bidirectional One-To-Many
Bidirectional One-To-One
Mapping Inheritance
Inheritance and Databases
Single-Table Inheritance
Mapping Single-Table Inheritance
Table-Per-Subclass
Table-Per-Subclass Mapping
Table-Per-Concrete-Class
The Hibernate Query Language
The Hibernate Query Language
Fundamentals
HQL Queries
Polymorphism
Named Parameters
Entity Parameters
Joining on Associations
Aggregate Methods
Updates and Deletes
Named Queries
Using Native SQL
|
|
androidtest |
Android Applications Testing |
21 hours |
This course aims at providing software testers with the required knowledge and skills in order to perform quality assurance tests for software applications that were developed for the Android platform. This course overviews the Android platform capabilities and provides you with up-to-date practices for performing the tests.
Introduction
What is Android?
Android SDK
Android JVM
The Software Stack
The Development Tools (ADT)
User Interface
Installing Development Tools
Content Providers
Services
Intents
Activities
Views
Configuration File
Simple Hello World
Application Artifacts
Asset Packaging Tool
Entry Point Activity
Intent
Calling Other Activities
The Activities Stack
Paused & Stopped Activities
SQLite Database
System Management
Separated Processes
Component & Integration Architecture
Application Resources
What are Resources?
String Resources
Layout Resources
Code Samples
Resource Reference Syntax
Compiled Resources
Compiled Animation Files
Compiled Bitmaps
Compiled UI View Definitions
Compiled Arrays
Compiled Colors
Compiled Strings
Compiled Styles
Compiled Arbitrary Raw XML Files
Uncompiled Resources
The .apk File
Assets
Assets & Resources Directory Structure
The Intent Concept
Introduction
Intent Filter
Use Intent to Start Activity
Android Available Intentions
Code Samples
Intent Categories
Late Run-Time Binding
Use Intent to Start Service
Broadcast Receivers
The Intent Object Structure
The Intent Component Name
The Intent Action
The Intent Data
The Intent Category
The Intent Extras
The Intent Flags
Intents Resolution
Intent Filter Structure
The Action Test
The Category Test
The Data Test
Multiple Matches
Android Predefined Intents
Samples
User Interface Controls
Introduction
GUI Sample in Source Code
GUI Sample in XML
GUI Sample in XML & Source Code
TextView
TextView Sample
TextView Style Sample
EditText
EditText Sample
AutoCompleteTextView
AutoCompleteTextView Sample
MultiAutoCompleteTextView
MultiAutoCompleteTextView Sample
Button
Button Sample
ImageButton
ImageButton Sample
ToggleButton
ToggleButton Sample
CheckBox Control
CheckBox Control Sample
RadioButton Control
RadioButton Control Sample
ListView
ListView Sample
GridView Control
GridView Control Sample
Date & Time Controls
Gallery Controller
MapView
WebView
Layout Managers
Introduction
LinearLayout
Layout Weight
Gravity
Samples
TableLayout
Padding Properties
RelativeLayout
AbsoluteLayout
FrameLayout
TabsHost
Menus and Dialogs
Introduction
Menu Interface
MenuItem Interface
SubMenu Interface
Menu Items Group
Menu Items Attributes
Container Menu Items
System Menu Items
Secondary Menu Items
Alternative Menu Items
Creating Menu,Sample
Menu Items Groups
Menu Items Events Handling
Overriding Callback Function
Define Listener
Using Intents
Expanded Menu
Icon Menus
Sub Menus
System Menus
Context Menus
Samples
Handling Menu Events
Creating Menu using XML
Alert Dialog
Prompt Dialog
Samples
Location Based Services
Introduction
The Map Key
The MD-5 Signature
Google Maps Key
Required Permissions
Code Sample
The Map Controller
Code Samples
Maps Overlays
Code Samples
The Geocoder Class
The Address Class
The LocationManager Class
The LocationListener Interface
The Debug Monitor Service (DMS)
Android Security Model
Introduction
Deployment
The keytool Utility
The jarsigner Utility
Deployment using Eclipse
Separated Processes
Declarative Permission Model
Application Life Cycle
Introduction
Activity Life Cycle Methods
The onStart() and onResume() Methods
The onPause() and onStope() Methods
Return Back to Previous Activity
The onStop() and onDestroy() Methods
The onCreate() Method
The onPause() Method
SQLite Database
Introduction
SQLite Implementation
The SQLiteOpenHelper Class
The onCreate() Method
The onUpgrade() Method
The onOpen() Method
The getWriteableDatabase() Method
The getReadableDatabase() Method
The SQLiteDatabase Class,The execSQL() Method
The insert() Method,The delete() Method
The rawQuery() Method()
Code Samples
The query() Method
Code Samples
Providers
Introduction
Android Built-In Content Providers
SQLite Database
Content Providers Architecture
Content Providers Registration
Content Providers REST Access
Content Providers URL Structure
Content Providers Mime Types
Using Content Provider
Retrieving Records
Adding Records
The Cursor Object
The ContentValues() Object
Content Provider Demo
File Management
Introduction
Creating Files
Accessing Simple Files
Accessing Raw Resources
XML Files Resources
SD Card External Storage
Background Applications
Introduction
Services
Background Threads
Making Toasts
Notifications
Other System Services
Background Activity Sample
Activity Data
Introduction
The Intent Class
Start Activity Methods
Passing Data between Activities
Coherent User Experience
Code Sample
Web View
Introduction
The WebView Class
The android.webkit Package
The INTERNET Permission
The loadUrl() Method
JavaScript Support
The loadData() Method
The WebView Methods
The WebViewClient Class
The WebChromeClient Class
Java Language
Introduction
The Limits
Third Party Java Libraries
Debugging
Introduction
Eclipse Java Editor
Eclipse Java Debugger
Logcat
Android Debug Bridge
Dalvik Debug Monitor Service
Traceview
Accelerometer
Introduction
The SensorManager Class
The SensorListenr Interface
Localization
Introduction
Default Resources
Current Locale
Testing
Custom Locale
Code Samples
Speech Input
Introduction
The RecognizerIntent Class
Start Speech Recognition
Google Server Side
The Language Model
Free Form Language Model
Web Search Language Model
Development Tools
Introduction
The aapt Tool
The adb Tool
The android Tool
The ddms Tool
The dx Tool
The draw9patch Tool
The emulator Tool
Android Applications Testing Practices - 4 Hours
Automated Testing
JUnit Testing
Using Assertions
Instrumentation Framework
On Device Testing
User Interface & Consistency
Functionality of Interaction with the OS
Networking Testing
Stress Test Conditions
International Support Testing
General Requirements
On Device Remote Testing
DeviceAnywhere Platform
Scenarios To Be Care Of
|
|
gfsjeeint |
Administering GlassFish Server with Java EE applications introduction |
21 hours |
Introduction to GlassFish Server
Overview of the Java EE Architecture
GlassFish Background
GlassFish Basic Architecture
GlassFish Basic Features
Installing and upgrading
Installation
Upgrade
Administering and deploying applications
Administration
High Availability Administration
Security
Application Deployment
Message Queue Administration
Troubleshooting
Troubleshooting
Error Message
Scaling and tuning the performance
Deployment Planning
Performance Tuning
Developing applications
Your First Cup: An Introduction to the Java EE Platform
The Java EE Tutorial
Application Development Guide
Message Queue Developer's Guide for Java Clients
Message Queue Developer's Guide for JMX Clients
Message Queue Developer's Guide for C Clients
Extending and embedding
Add-On Component Development Guide
Embedded Server Guide
|
|
820 |
ADO.NET 4.0 Development |
28 hours |
Objectives
ADO.NET 4.0 is Microsoft’s latest API for accessing data. This course covers the core features using Visual Studio 2010, including connected and disconnected data access.
The course describes how to manage connections and execute commands, how to create and use DataSets effectively, and how to use the Entity Framework.
This course can be used as part of your preparation for Microsoft Exam 70-516: TS: Accessing Data with Microsoft .NET Framework 4
After completing this course, delegates will be able to:
Connect to a Database and Access Data
Execute Commands and Call Stored Procedures
Work with Data Using LINQ
Work with Data Using the Entity Framework
Use WCF Data Services
Audience
Developers who want to write data-access code for the .NET 4.0 platform.
Module 1: Connecting to a Database and Reading Data
Evolution of ADO.NET
Managing connection strings
Managing connections
Reading data from a database
Connection pooling
Handling SQL exceptions
Module 2: Executing Commands
Executing query and non-query commands
Calling stored procedures
Specifying parameters
Asynchronous queries
Module 3: Transactions
Recap of ACID transactions
Managing local transactions
Managing distributed transactions
Module 4: Using ADO.NET in GUI Applications
Implementing a data access layer
Binding data to WPF user interfaces
Updating the database
Module 5: Disconnected Data Access
Populating and saving a DataSet
Adding, modifying, and deleting data in a DataSet
Using DataViews
Module 6: Creating and Using Typed DataSets
Creating a typed DataSet
Managing data in a typed DataSet
Adding code to a typed DataSet
Adding queries to a typed DataSet
Using DataSets as XML
Module 7: Getting Started with LINQ
Using LINQ with arrays, collections, and DataSets
LINQ under the hood
LINQ techniques
Performing joins
Module 8: Using LINQ to SQL
Overview of LINQ to SQL
Defining relations
Generating mapping classes
Inserting, updating, and deleting entities
Saving changes
Handling optimistic concurrency conflicts
Module 9: Creating an Entity Model Using the Entity Framework
Overview of the Entity Framework
Overview of entity data models
Defining an entity data model
Modifying an entity data model
Module 10: Working with Data Using the Entity Framework
Using LINQ to Entities
Using Entity SQL
Modifying entities
Attaching/detaching entities
Module 11: Going Further with Entity Framework Mapping
Defining relationships
Inheritance scenarios
Implementing inheritance mappings
Module 12: Entity Framework POCOs
Getting started with POCOs
POCO configuration
Working with POCO objects
Using POCO in ASP.NET MVC
Module 13: WCF Data Services
Getting started with WCF
Data Services WCF Data Services walkthrough
Additional considerations
Module 14: Developing Reliable Applications
Using performance counters
Handling exceptions
Protecting data
Module 15: Using Synchronization Services
Overview of Synchronization Services
Downloading and uploading data by using Synchronization Services
|
|
restapi |
REST API - a pattern of exchange of information between sites |
14 hours |
The course is designed for developers, web applications, aims to provide opportunities offered by the REST architectural pattern by which you can communicate between sites.
REST - base
The need for the exchange of information between sites
HTTP POST / GET / PUT / DELETE
Services such MushUp and popular applications
Services using REST
Conventions Rest
Mapping CRUD operations on HTTP calls
Conventions API URL structure
Passing Parameters
Return Values
HTTP statuses
JSON - a universal format for the exchange of information
API services
Examples of the popular API
RESTful frameworks
Create a REST API - Server
Gathering requirements and identify functionality
Design and API documentation
Installing the required libraries
Business Object - mapping the class
Controller methods
Representation of a business object as JSON
HTTP Headers - as metadata
Testing the API using cURL
Authentication mechanisms
|
|
angjsbas |
AngularJS Basics |
14 hours |
Angular JS (AKA Angular) is a JavaScript library for rapid app development.
Audience
developers
programmers
javascript architects
Objectives
Shift midset from procedural/OO way of programing to Angular way
Participants can use AngularJS to create Single Page Applications
Format of the course
40% lectures, 60% labs
Introduction
Why AngularJS?
Alternatives
Extensibility
The basics:
Add some control
Data Binding
Controller
Plain JavaScript
Wire up a Backend
Deep Linking
Form Validation
Server Communication
Create Components
Directives
Reusable Components
Localization
Embed and Inject
Embeddable
Injectable
Testable
|
|
matlab2 |
MATLAB Fundamentals |
21 hours |
This three-day course provides a comprehensive introduction to the MATLAB technical computing environment. The course is intended for beginning users and those looking for a review. No prior programming experience or knowledge of MATLAB is assumed. Themes of data analysis, visualization, modeling, and programming are explored throughout the course. Topics include:
Working with the MATLAB user interface
Entering commands and creating variables
Analyzing vectors and matrices
Visualizing vector and matrix data
Working with data files
Working with data types
Automating commands with scripts
Writing programs with logic and flow control
Writing functions
Part 1
A Brief Introduction to MATLAB
Objectives: Offer an overview of what MATLAB is, what it consists of, and what it can do for you
An Example: C vs. MATLAB
MATLAB Product Overview
MATLAB Application Fields
What MATLAB can do for you?
The Course Outline
Working with the MATLAB User Interface
Objective: Get an introduction to the main features of the MATLAB integrated design environment and its user interfaces. Get an overview of course themes.
MATALB Interface
Reading data from file
Saving and loading variables
Plotting data
Customizing plots
Calculating statistics and best-fit line
Exporting graphics for use in other applications
Variables and Expressions
Objective: Enter MATLAB commands, with an emphasis on creating and accessing data in variables.
Entering commands
Creating variables
Getting help
Accessing and modifying values in variables
Creating character variables
Analysis and Visualization with Vectors
Objective: Perform mathematical and statistical calculations with vectors, and create basic visualizations. See how MATLAB syntax enables calculations on whole data sets with a single command.
Calculations with vectors
Plotting vectors
Basic plot options
Annotating plots
Analysis and Visualization with Matrices
Objective: Use matrices as mathematical objects or as collections of (vector) data. Understand the appropriate use of MATLAB syntax to distinguish between these applications.
Size and dimensionality
Calculations with matrices
Statistics with matrix data
Plotting multiple columns
Reshaping and linear indexing
Multidimensional arrays
Part 2
Automating Commands with Scripts
Objective: Collect MATLAB commands into scripts for ease of reproduction and experimentation. As the complexity of your tasks increases, entering long sequences of commands in the Command Window becomes impractical.
A Modelling Example
The Command History
Creating script files
Running scripts
Comments and Code Cells
Publishing scripts
Working with Data Files
Objective: Bring data into MATLAB from formatted files. Because imported data can be of a wide variety of types and formats, emphasis is given to working with cell arrays and date formats.
Importing data
Mixed data types
Cell arrays
Conversions amongst numerals, strings, and cells
Exporting data
Multiple Vector Plots
Objective: Make more complex vector plots, such as multiple plots, and use color and string manipulation techniques to produce eye-catching visual representations of data.
Graphics structure
Multiple figures, axes, and plots
Plotting equations
Using color
Customizing plots
Logic and Flow Control
Objective: Use logical operations, variables, and indexing techniques to create flexible code that can make decisions and adapt to different situations. Explore other programming constructs for repeating sections of code, and constructs that allow interaction with the user.
Logical operations and variables
Logical indexing
Programming constructs
Flow control
Loops
Matrix and Image Visualization
Objective: Visualize images and matrix data in two or three dimensions. Explore the difference in displaying images and visualizing matrix data using images.
Scattered Interpolation using vector and matrix data
3-D matrix visualization
2-D matrix visualization
Indexed images and colormaps
True color images
Part 3
Data Analysis
Objective: Perform typical data analysis tasks in MATLAB, including developing and fitting theoretical models to real-life data. This leads naturally to one of the most powerful features of MATLAB: solving linear systems of equations with a single command.
Dealing with missing data
Correlation
Smoothing
Spectral analysis and FFTs
Solving linear systems of equations
Writing Functions
Objective: Increase automation by encapsulating modular tasks as user-defined functions. Understand how MATLAB resolves references to files and variables.
Why functions?
Creating functions
Adding comments
Calling subfunctions
Workspaces
Subfunctions
Path and precedence
Data Types
Objective: Explore data types, focusing on the syntax for creating variables and accessing array elements, and discuss methods for converting among data types. Data types differ in the kind of data they may contain and the way the data is organized.
MATLAB data types
Integers
Structures
Converting types
File I/O
Objective: Explore the low-level data import and export functions in MATLAB that allow precise control over text and binary file I/O. These functions include textscan, which provides precise control of reading text files.
Opening and closing files
Reading and writing text files
Reading and writing binary files
Note that the actual delivered might be subject to minor discrepancies from the outline above without prior notification.
Conclusion
Note that the actual delivered might be subject to minor discrepancies from the outline above without prior notification.
Objectives: Summarise what we have learnt
A summary of the course
Other upcoming courses on MATLAB
Note that the course might be subject to few minor discrepancies when being delivered without prior notifications. |
|
krakenjs |
Extending Express with Kraken JS |
14 hours |
Kraken is a secure and scalable layer that extends express by providing structure and convention.
Audience
This course targets front end web developers and engineers seeking to utilize Kraken JS with their Node JS express web app.
Getting started
The Kraken Suite
Lusca
Kappa
Makara
Adaro
Structure of a Project
Configuration
Security
Routes
Models
Templates
Localization
Grunt tasks
Examples
Recommended patterns |
|
ios_swift3 |
iOS (iPhone and iPad Development) in Swift for iOS 10 and Xcode 8 - Swift 3 |
35 hours |
This 5 day course is for developers who want to learn how to develop applications for iPhone and iPad running on iOS 10. The course is hands on and shows how to develop applications from scratch using Apple's new Swift programming language using the Xcode8 IDE.
During this course, 4 projects will be developed and one project which will be your own idea will be developed. The course ends with developing a new application from scratch in Swift and making it live on app store. ( For that you must have an Apple Account).
This course can only be run on Apple hardware such as a MacBook or a Mac Mini. Delegates need to have registered with Apple and have an Apple ID which is required to download software. Delegates wishing to run the applications developed during the course on an iPhone or iPad need to be registered as iOS developers with Apple and have registered their device for development. Apple charge $99 per year to register as an iOS developer.
Day 1:
OOPS concepts
What is software
Organized v/s un-organized rooms
Why Software
Why iOS
Apple History
iOS History
Apple’s USP
What Apple is famous for
UX v/s UI
IDE?
XCode
XCode installation
Why Objective C and now why Swift?
Wow Factors in Swift
Swift Basics
Variables
Constants
Hello World in Swift
Label making via code
ImageView
ImageView animations
NSTimer
Responder Chain - touchBegan, touchMoved, etc methods
UiApplication main delegate
Application Life Cycle
View Life Cycle
Any
Optionals
internal, public, private
init
deinit
Playground
Application to Do: Dots Game: https://itunes.apple.com/app/the-dots-free/id850315430?mt=8
Day 2:
UIView animations
Extenstion
UITable View
Custom Cell in Table View
Delegate and Data Source Methods in Delegates
Header, Footer, Height, etc of Table View
Brief of Collection View
Deque in table view
Mark
Optionals
didSet
willSet
Guard
2x and 3x concepts
Navigate from one view to other
UINavigation Controller
Present a Controller
StoryBoards
Xibs
Constraints
Size classes
Protocols - Required and optional
Memory management
Application to Do: Notes app : Adding, deleting and updating note
Days 3:
Gestures
Closure
Groups and folders
Gesture recognizers
XML Parsing
NSJSon Serialization
Converting Data to Json
File Manager
Tuples
Enum
For-in
While
Webservices
URL Session
URLRequest
Why eco system of apple is best
Printable - description
Hashable
UIAlertView
UIActivityIndicatorView
Application to Do: Getting data from server from an open API app and make a table view and populate data and show its details also.
Days 4:
Lazy loading of images
Lazy properties
NSOperationQueue
GCD
Directory concept and security of apps NSSearchDomain
Tab Bar controller
Localization
Key Chain
User Defaults
PLists
FileManager
SQlite
Extensiosn
Social media integration: Make own sharable content
UITextField
UITextView
UISegementControl
UISlider
UiSwtich
UIProgessBar
UIPageControl
UIStepper
UIScrollView
UIPicker
UIActionSheet
UIWebView
SearchBar
New target : Apple Watch, Extensions, Keyboard, Today, etc
NSNotifications in IOS
Adding third party libraries
Core Data
Deployment and distribution
Running app on real devices
Application to Do: Getting data from server from an open API app and make a table view and populate data and show its details also and show Search bar and search for something and Core
Days 5:
Push Notification - Silent and Push
Localization
Overview of Objective C
Properties
Categories
Functions syntax
.h and .m file
Property attributes readWrite and readOnly
Property attributes strong, weak and copy
Property attributes atomic and non-atomic
Uploading app to app store
Application of your own idea |
|
OpenNN |
OpenNN: Implementing neural networks |
14 hours |
OpenNN is an open-source class library written in C++ which implements neural networks, for use in machine learning.
In this course we go over the principles of neural networks and use OpenNN to implement a sample application.
Audience
Software developers and programmers wishing to create Deep Learning applications.
Format of the course
Lecture and discussion coupled with hands-on exercises.
Introduction to OpenNN, Machine Learning and Deep Learning
Downloading OpenNN
Working with Neural Designer
Using Neural Designer for descriptive, diagnostic, predictive and prescriptive analytics
OpenNN architecture
CPU parallelization
OpenNN classes
Data set, neural network, loss index, training strategy, model selection, testing analysis
Vector and matrix templates
Building a neural network application
Choosing a suitable neural network
Formulating the variational problem (loss index)
Solving the reduced function optimization problem (training strategy)
Working with datasets
The data matrix (columns as variables and rows as instances)
Learning tasks
Function regression
Pattern recognition
Compiling with QT Creator
Integrating, testing and debugging your application
The future of neural networks and OpenNN |
|
octnp |
Octave not only for programmers |
21 hours |
Course is dedicated for those who would like to know an alternative program to the commercial MATLAB package. The three-day training provides comprehensive information on moving around the environment and performing the OCTAVE package for data analysis and engineering calculations. The training recipients are beginners but also those who know the program and would like to systematize their knowledge and improve their skills. Knowledge of other programming languages is not required, but it will greatly facilitate the learners' acquisition of knowledge. The course will show you how to use the program in many practical examples.
Introduction
Simple calculations
Starting Octave, Octave as a calculator, built-in functions
The Octave environment
Named variables, numbers and formatting, number representation and accuracy, loading and saving data
Arrays and vectors
Extracting elements from a vector, vector maths
Plotting graphs
Improving the presentation, multiple graphs and figures, saving and printing figures
Octave programming I: Script files
Creating and editing a script, running and debugging scripts,
Control statements
If else, switch, for, while
Octave programming II: Functions
Matrices and vectors
Matrix, the transpose operator, matrix creation functions, building composite matrices, matrices as tables, extracting bits of matrices, basic matrix functions
Linear and Nonlinear Equations
More graphs
Putting several graphs in one window, 3D plots, changing the viewpoint, plotting surfaces, images and movies,
Eigenvectors and the Singular Value Decomposition
Complex numbers
Plotting complex numbers,
Statistics and data processing
GUI Developmen |
|
javaperf |
Java Performance |
35 hours |
What will you learn?
Performance tips all come with a shelf life that is linked to the particular technology to which they are applied. Once that technology changes or is no longer used, the tips become useless at best and harmful at worst. For this reason we have purposely designed a course that focuses on providing you with something more than just tricks to get the latest and greatest framework to meet your performance needs. One of the tools we aim to leave you with is a methodology that we've used over the years on a regular basis. This methodology has helped us quickly identify and solve hard performance issues.
The other equally important aspect of performance tuning is tooling. A good portion of the course focuses on a number of open source tools that we have found to be useful in our campaigns to stamp out performance bottlenecks.
Beyond methodology and tooling, we look at some of the fundamentals of Java technology. This includes the inner workings of the Java memory management and HotSpot/JIT technologies.
Objectives
how to apply rigor to the task of performance tuning
how to setup a performance tuning environment
importance of performance tuning requirements and goals
tools needed to conduct a performance investigation
benchmarking and micro-benchmarking skills
Java memory and execution models
Tools & Methodology
Defining performance and performance tuning
Common performance problems
Profiling, and monitoring with professional tools
Execution, memory and thread profilers
System level monitoring
Java Management eXtentions
Architecture
Planning for performance
Patterns and anti-patterns
Messaging
Architectures for performance
Coding Best Practices
Big gains
user perceptions
Macro and micro benchmarking
Selected Java Libraries including String, I/O and Collections
XML parsing
Serialization
Concurrency
Memory Management
Java Virtual Machine heap spaces
Garbage collection algorithms
Object life-cycle
Garbage collection logging and monitoring
Heap tuning strategies
|
|
androidfun |
Android Fundamentals |
56 hours |
Android is an open source platform developed by Google for mobile development.
Applications for the Android platform are developed in Java.
This course overviews Android's fundamental topics.
Introduction
What is Android?
Android SDK
Android JVM
The Software Stack
The Development Tools (ADT)
User Interface
Installing Development Tools
Content Providers
Services
Intents
Activities
Views
Configuration File
Simple Hello World
Application Artifacts
Asset Packaging Tool
Entry Point Activity
Intent
Calling Other Activities
The Activities Stack
Paused & Stopped Activities
SQLite Database
System Management
Separated Processes
Component & Integration Architecture
Application Resources
Introduction
What are Resources?
String Resources
Layout Resources
Code Samples
Resource Reference Syntax
Compiled Resources
Compiled Animation Files
Compiled Bitmaps
Compiled UI View Definitions
Compiled Arrays
Compiled Colors
Compiled Strings
Compiled Styles
Compiled Arbitrary Raw XML Files
Uncompiled Resources
The .apk File
Assets
Assets & Resources Directory Structure
The Intent Concept
Introduction
Intent Filter
Use Intent to Start Activity
Android Available Intentions
Code Samples
Intent Categories
Late Run-Time Binding
Use Intent to Start Service
Broadcast Receivers
The Intent Object Structure
The Intent Component Name
The Intent Action
The Intent Data
The Intent Category
The Intent Extras
The Intent Flags
Intents Resolution
Intent Filter Structure
The Action Test
The Category Test
The Data Test
Multiple Matches
Android Predefined Intents
Samples
User Interface Controls
Introduction
GUI Sample in Source Code
GUI Sample in XML
GUI Sample in XML & Source Code
TextView
TextView Sample
TextView Style Sample
EditText
EditText Sample
AutoCompleteTextView
AutoCompleteTextView Sample
MultiAutoCompleteTextView
MultiAutoCompleteTextView Sample
Button
Button Sample
ImageButton
ImageButton Sample
ToggleButton
ToggleButton Sample
CheckBox Control
CheckBox Control Sample
RadioButton Control
RadioButton Control Sample
ListView
ListView Sample
GridView Control
GridView Control Sample
Date & Time Controls
Gallery Controller
MapView
WebView
Layout Managers
Introduction
LinearLayout
Layout Weight
Gravity
Samples
TableLayout
Padding Properties
RelativeLayout
AbsoluteLayout
FrameLayout
TabsHost
Menus and Dialogs
Introduction
Menu Interface
MenuItem Interface
SubMenu Interface
Menu Items Group
Menu Items Attributes
Container Menu Items
System Menu Items
Secondary Menu Items
Alternative Menu Items
Creating Menu
Sample
Menu Items Groups
Menu Items Events Handling
Overriding Callback Function
Define Listener
Using Intents
Expanded Menu
Icon Menus
Sub Menus
System Menus
Context Menus
Samples
Handling Menu Events
Creating Menu using XML
Alert Dialog
Prompt Dialog
Samples
Touchscreens
Introduction
Motion Events
Events Sequences
Events Handling
Handling Method
Samples
Style Definition
Introduction
Style Definition
Samples
Style Definitions Inheritance
Style Properties
Theme Definition
Predefined Themes
Predefined Themes
Inherit Predefined Theme
App Widgets Development
App Widgets Overview
Practical Samples
Basic App Widget Structure
Configuration Activity
Design Guidelines
Location Based Services
Introduction
The Map Key
The MD-5 Signature
Google Maps Key
Required Permissions
Code Sample
The Map Controller
Code Samples
Maps Overlays
Code Samples
The Geocoder Class
The Address Class
The LocationManager Class
The LocationListener Interface
The Debug Monitor Service (DMS)
Web Services
Introduction
The HttpClient Class
The HttpGet Class
The HttpPost Class
The HttpResponse Class
Code Samples
HTTP Get Request
HTTP Post Request
Code Samples
Timeout Exceptions
Threading Issues
Android Services
Introduction
Creating Services
The Service Class
Background Tasks
Inter Process Communication
Separated Implementation
Local ServiceRemote Services
AIDL Compiler
Creating Remote ServiceUsing Remote Service
Samples
Media Framework
Introduction
Playing Audio
Playing Video
Simple MP3 Player Demo
Simple Video Player Demo
Android Security Model
Introduction
Deployment
The keytool Utility
The jarsigner Utility
Deployment using Eclipse
Separated Processes
Declarative Permission Model
Graphics Animation
Introduction
Frame by Frame Animation
Code Sample
Tween Animation
Code Samples
Basic Graphics
Introduction
The Drawable Abstract Class
Code Sample
The ShapeDrable Abstract Class
Code Sample
OpenGL Graphics
Introduction
The glVertexPointer Method
The glDrawElements Method
Code Sample
Customized Views
Introduction
Customized Progress Bar
Model View Controller
Android Threads
Introduction
The UI Thread
The Single Thread Rule
The runOnUiThread Method
The post Method
The postDelayed Method
The Handler Class
The AsyncTask Utility Class
Sending Messages to Handler
Background Threads Caveats
Application Life Cycle
Introduction
Activity Life Cycle Methods
The onStart() and onResume() Methods
The onPause() and onStope() Methods
Return Back to Previous Activity
The onStop() and onDestroy() Methods
The onCreate() Method
The onPause() Method
SQLite Database
Introduction
SQLite Implementation
The SQLiteOpenHelper Class
The onCreate() Method
The onUpgrade() Method
The onOpen() Method
The getWriteableDatabase() Method
The getReadableDatabase() Method
The SQLiteDatabase Class
The execSQL() Method
The insert() Method
The delete() Method
The rawQuery() Method()
Code Samples
The query() Method
Code Samples
Content Providers
Introduction
Android Built-In Content Providers
SQLite Database
Content Providers Architecture
Content Providers Registration
Content Providers REST Access
Content Providers URL Structure
Content Providers Mime Types
Using Content Provider
Retrieving Records,Adding Records
The Cursor Object,The ContentValues() Object
Content Provider Demo
Developing Content Providers
Code Samples
The SimpleCursorAdapter Class
The onCreate() Method
The query() Method
The insert() Method
The update() Method
The delete() Method
The getType() Method
Code Samples
Changes Notification
Shared Preferences
Introduction
The SharedPreferences Interface
The SharedPreferences.Editor Class
Code Samples
File Management
Introduction
Creating Files
Accessing Simple Files
Accessing Raw Resources
XML Files Resources
SD Card External Storage
Dalvik VM
Introduction
Comparing with JVM
The dex File Format
The dx Utility
Garbage Collector
Controlling the Dalvik VM
Background Applications
Introduction
Services
Background Threads
Making Toasts
Notifications
Other System Services
Background Activity Sample
Activity Data
Introduction
The Intent Class
Start Activity Methods
Passing Data between Activities
Coherent User Experience
Code Sample
SMS Messages
Introduction
The SMSManager Class
The SEND_SMS Permission
Sending SMS
Receiving SMS
Telephony
Introduction
Initiate Phone Calls
The android.telephony Package
The CallLocation Class
The PhoneStateListener Class
The ServiceState Class
The TelephonyManager Class
Limitations,Android VoIP
Web View
Introduction
The WebView Class
The android.webkit Package
The INTERNET Permission
The loadUrl() Method
JavaScript Support
The loadData() Method
The WebView Methods
The WebViewClient Class
The WebChromeClient Class
Java Language
Introduction
The Limits
Third Party Java Libraries
Debugging
Introduction
Eclipse Java Editor
Eclipse Java Debugger
Logcat
Android Debug Bridge
Dalvik Debug Monitor Service
Traceview
Instrumentation Framework
Adapters
Introduction
Classes Hierarchy
The Adapter Purpose
The SimpleCursorAdapter Class
The ArrayAdapter Class
Live Wallpapers
Introduction
Develop Live Wallpaper
User Interaction
The user-sdk Element
The uses-feature Element
PerformanceCode Samples
BroadcastReceiver
Introduction
Registering a Receiver
Receiver Life Cycle
Code Samples
Bluetooth
Introduction
The Capabilities
The BluetoothAdapter Class
The BluetoothDevice Class
The BluetootnSocket Interface
The BluetoothServerSocket Class
The Bluetooth Class
Bluetooth Permission
Setting Up Bluetooth
Finding Devices
Querying Paired Devices
Devices Discovery
Enabling Discoverability
Devices Connection
Code Samples
Text To Speech
Introduction
Pico Engine
Demo
Single TTS Engine
Code Samples
Android Search
Introduction
Suggestions Providers
The onSearchRequest() Method
Suggestion Provider
Camera
Introduction
Auto Focus
Picture Parameters
Scene Modes
Accelerometer
Introduction
The SensorManager Class
The SensorListenr Interface
Compass
Introduction
The SensorManager Class
The SensorListenr Interface
Vibration
Introduction
The Vibrator Class
Vibration Sequences
WiFi Connectivity
Introduction
The WifiManager Class
User Permissions
Searching for Hot Spots
Connecting Hot Spots
Networking
Introduction
Java Networking Classes
Android Networking Classes
Apache Networking Classes
Input Method Framework
Introduction
The android:inputType Attribute
Customized IMF
Device Rotation
Introduction
Two XML Layout Documents
Code Samples
Localization
Introduction
Default Resources
Current Locale
Testing
Custom Locale
Code Samples
Memory Management
The Application Context
Screen Orientation Changes
Static Inner Classes
Weak References
Garbage Collector
Speech Input
Introduction
The RecognizerIntent Class
Start Speech Recognition
Google Server Side
The Language Model
Free Form Language Model
Web Search Language Model
Development Tools
Introduction
The aapt Tool
The adb Tool
The android Tool
The ddms Tool
The dx Tool
The draw9patch Tool
The emulator Tool
Instant Messaging
Introduction
Jabber Protocol
GTalk Interaction
|
|
mql4prog |
MQL4 Programming |
21 hours |
MetaQuotes Language 4 (MQL4) is a new built-in language for programming of trading strategies. This language allows creation of your own Expert Advisors that make trading management automated and are perfectly suitable for implementing one's own trade strategies. MQL4 can be used for the creation of one's own Custom Indicators, Scripts, and Libraries.
Basics
Standard constants
Predefined variables
Program Run
Account information
Array functions
Checkup
Client terminal
Common functions
Conversion functions
Custom indicators
Date & Time functions
File functions
Global variables
Math & Trig
Object functions
String functions
Technical indicators
Timeseries access
Trading functions
Window functions
Obsolete functions
|
|
aspnetmvc45 |
ASP.NET MVC 4.5 Web Development |
28 hours |
Objectives
Over the last few years there has been a steady move towards Model-View-Controller (MVC) architectures for Web applications. MVC Web applications offer a clean separation of concerns between the business-logic classes, Web pages, and the controller. Microsoft ASP.NET MVC 4.5 offers Web developers all the benefits of MVC allied with all the power of the .NET platform. This course provides full coverage of ASP.NET MVC 4.5.
After completing this course, delegates will be able to:
Understand the Role of the Model, View, and Controller Design Pattern
Create Industrial-Strength Applications
Apply Test Driven Development Methods
Implementing Navigation Between Pages
Implement Rich User Interfaces with JQuery and Ajax
Audience
ASP.NET developers who want to use the MVC architecture.
Module 1: Introduction to ASP.NET MVC
Recap of ASP.NET Web development
Key benefits of ASP.NET MVC
The role of the model, view, and controller
Module 2: Getting Started with ASP.NET MVC
Preparing your development environment for ASP.NET MVC
Creating an ASP.NET MVC project
Understanding the structure of an ASP.NET MVC project
Naming conventions
Creating views
Defining controllers
Defining a data model
Module 3: Creating a Complete ASP.NET MVC Application
Creating strongly-typed views
Understanding URLs and action methods
Using HTML helpers
Handling form post-backs; Data validation
Module 4: Using the Razor View Engine
Razor design goals
Implementing a Razor view
Razor syntax
Accessing model data in Razor views
Module 5: Industrial-Strength ASP.NET MVC Applications
ASP.NET application architecture best practices
Implementing a repository and Entity Framework data model
Using Dependency Injection; Implementing a custom controller factory
Test-Driven Development with ASP.NET MVC
Module 6: View Techniques
Defining and using custom HTML helpers
Defining a layout/master page
Using styles
Defining and using partial views
Razor helper method syntax
Module 7: Implementing Navigation: Defining view-model classes
Implementing data filtering in a controller
Understanding the routing mechanism
Adding custom entries to a route table
Defining defaults, parameters, and validation
Generating URLs and hyperlinks
Custom route constraints
Module 8: State Management
Using hidden fields
Session and application state
Custom model bindings
Module 9: Using Ajax and jQuery with ASP.NET MVC
Overview of Ajax and ASP.NET MVC; Unobtrusive Ajax;
Using Ajax action links
Overview of jQuery
jQuery techniques
Using jQuery UI
Module 10: Additional ASP.NET MVC 4.5 Techniques
View scaffold templates
Controller scaffold templates
Dependency injection with Unity
Module 11: Test Driven Development with ASP.NET MVC
Recap of TDD
Walk-through of using TDD with ASP.NET MVC
Module 12: Additional Techniques
Controller techniques
Filters
Model binding
|
|
phppatref |
PHP Patterns and Refactoring |
21 hours |
The course is designed for experienced programmers who want to explore issues related to the use of patterns and refactoring. Each participant know the properties and practical examples of the use of these patterns, which in turn will enable the efficient build correct the application code.
Introduction to Design Patterns
What is a design pattern
elements of pattern
Advantages and disadvantages of using patterns
GoF Design Patterns
patterns creative
Builder
Factory (Abstract Factory, Factory Method)
Prototype
Singleton
structural patterns
Delegator
Interface
Facade
Composite
Immutable
Adapter
Decorator
Proxy
behavioral patterns
Command
Template method
Observer
Chain of responsibility (and Intercepting Filter)
Observer (2 version)
Strategy
Patterns of Enterprise Application Architecture Web
MVC - Model View Controller
HMVC, MVP
Inversion of Control
Dependency Injection Container
Active Record
The concept of entity and Repositories
Decomposition of the system
Examples of component-based Symfony 2 and Zend Framework 2
Refactoring
Debt technology
What is refactoring?
Tools to support refactoring
phpmd (Software metrics)
phpcpd
phpc
Typical code requires refactoring
Jenkins Continuous Integration Server
|
|
mwdev1 |
MediaWiki for Developers |
21 hours |
This course jumps into the deep end of the pool; we are going to go over every essential aspect of MediaWiki development, including:
Mapping out the core code
Creating extensions
Modifying and Creating Custom Skins
This course is for intermediate-level LAMP developers and up, preferably with some styling experience.
The Structure and Purpose of MediaWiki
Where we are now
How it ended up this way
Current efforts, and the future
The path router
The startup and shutdown of MediaWiki
The Includes Directory
'Here be dragons': a map to the includes directory
Walking through
Marking out your points of interest
Essential files, classes, and methods
Database
The parser
Image Handling
The API
The Job Queue
Pages, articles, revisions, and titles
Global functions
Extensions
What you need to know
A Game of Chess: Choosing your moves wisely
Hooks
The limitation of hooks
Object-oriented extension versus hooking
Dead ends, and how to avoid them
When you have no other choice: modifying the core code
Special Pages
Troubleshooting
Where did it go?
Tracing the path of an object
What went wrong?
Debugging in MediaWiki
Finding the root of an error
Exceptions
Skins
We're extensions too!
Vector, and the current skinning efforts in MediaWiki
What is changing
Creating a skin from scratch
The classes you must work with (or around)
Creating the raw skin
Theming, and CSS classes at your disposal
JavaScript modules and page output
MediaWiki and the Database
The schema
Contributing, Gerrit, and working with the team |
|
matlabml1 |
Introduction to Machine Learning with MATLAB |
21 hours |
MATLAB Basics
MATLAB More Advanced Features
BP Neural Network
RBF, GRNN and PNN Neural Networks
SOM Neural Networks
Support Vector Machine, SVM
Extreme Learning Machine, ELM
Decision Trees and Random Forests
Genetic Algorithm, GA
Particle Swarm Optimization, PSO
Ant Colony Algorithm, ACA
Simulated Annealing, SA
Dimenationality Reduction and Feature Selection
|
|
javaadvanced |
Java Advanced - one day |
7 hours |
Introduces contect for Advanced java programmers, usually developing large scale applications, frameworks or libraries.
This course is mostly labs (around 60%), the rest is discussions and presentation.
We mostly use the newest version of Java for this course, but it can also be delivered as a private course on older versions of Java.Generics
Why, when and benefit/cost of Genercis
Type Erasure
Type Boundaries
Wildcards
Generic Methods
Multithreading
Java Thread System
Managing Threads
Interacting with Threads and Thread State
Thread Synchronization
Volatile Fields and Synchronized Methods
wait and notify pattern
join and sleep pattern
Concurrency API
Atomic Operations
Thread Pools
Reflection
When to use and when not to use reflection
Uses for Meta-Data
The Reflection API
The Class<T> Class
The java.lang.reflect Package
Reading Type Information
Navigating Inheritance Trees
Dynamic Instantiation
Dynamic Invocation
Reflecting on Generics
Accessing private fields using reflection
Annotations
Aspect-Oriented Programming (AOP)
Built-In Annotations
Annotations Model
Annotation Types and Annotations
Annotations vs. Descriptors (XML)
Multi process communication
Shared memory
Socekts
Non-Blocking Sockets
TCP
URL Objects
HTTP and Other TCP Servers
Datagram Clients and Servers
Multi-Threading in Servers
|
|
ProgApp |
Progressive applications |
14 hours |
Audience
web developers
app developers
Format of the course
30% lectures, 60% labs, 10% tests
Convergence of web and mobile
Reasons for developing progressive applications
speed and performance (compared to websites)
security
offline capabilities
push notifications
improved bounce rates
app-like feel and functionality
bypassing of App Stores
Enabling your website (requirements)
secure HTTPS connection
JSON Manifest
Service Worker
Building your first app
Using Service Workers to enable your app to work offline
Caching data
Serving push notifications
Updating content
Data manipulation
Event listeners and commands
Customizing responses to network requests depending on whether online/offline status
Data persistence and messaging
Accessing Cache API, Fetch API, IndexedDB API, postMessage(), etc.
Increasing user engagement through Notification API
Using cached assets in your application
Configuring Web App Manifest
Adding the app to the Home Screen
Application shell architecture
UI considerations |
|
accumulo |
Apache Accumulo: Building highly scalable big data applications |
21 hours |
Apache Accumulo is a sorted, distributed key/value store that provides robust, scalable data storage and retrieval. It is based on the design of Google's BigTable and is powered by Apache Hadoop, Apache Zookeeper, and Apache Thrift.
This courses covers the working principles behind Accumulo and walks participants through the development of a sample application on Apache Accumulo.
Audience
Application developers
Software engineers
Technical consultants
Format of the course
Part lecture, part discussion, hands-on development and implementation, occasional tests to gauge understanding
Introduction
Installing Accumulo
Configuring Accumulo
Understanding Accumulo's data model, architecture, and components
Working with the shell
Database operations
Configuring your tables
Accumulo iterators
Developing an application in Accumulo
Securing your application
Reading and writing secondary indexes
Working with Mapreduce, Spark, and Thrift Proxy
Testing your application
Troubleshooting
Deploying your application
Accumulo Administrative tasks |
|
titanium |
Titanium: build native mobile apps using Javascript |
7 hours |
Appcelerator Titanium is an open-source development framework that enables the creation of native mobile apps on iOS, Android and Windows Phone from a single JavaScript codebase.
This training introduces the fundamentals of Titanium and walks participants through the creation of a Titanium mobile application.
Audience
Web application developers
Format of the course
Heavy emphasis on hands-on practice. Most of the concepts are learned through samples, exercises and hands-on development.
Introduction
Titanium vs PhoneGap
Overview of the Titanium architecture
Installation and setup
Preparing your development environment
Preparing the app interface
Designing the app
Windows and views
Controls, input and interactivity
Using events, variables and callbacks
Reading and writing to the file system
Adding social media support to your app
Adding notification support to your app
Adding support for gestures to your app
Adding media support to your app
Adding map support to your app
Adding support for other phone native features
Enhancing the app interface with styles
Extending Titanium with modules
Testing your app
Debugging your app
Deploying your app
Contributing to the community
Closing remarks |
|
jquery |
jQuery |
14 hours |
This course has been created for web developers who want to simplify JavaScript development.
This course covers the basics of jQuery all the way up to building plugins.
jQuery Background
History
Further development
jQuery versions, development and compressed
Preparing environment to support auto-completion and help
Simplify JavaScript development with jQuery
jQuery structure and components
Core
Selectors
Attributes
Traversing
Manipulation
Effects
Ajax
XMLHttpRequest object
using HTTP GET, POST
Using JSON objects
jQuery Events
Binding and unbinding events
Convenient event helper methods
jQuery event object
Event features
Plugins
Finding a plugin
How to use jQuery plugins
How to minimize the size of the plugins
jQueryUI
|
|
androidwidget |
Android App Widgets Development |
7 hours |
Android app widgets are small application views that we can embed into other activities, such as the home screen. This short course teaches you how to develop android app widgets so the user will be able to add them into their android phone home screen.
App Widgets Overview
App Widget, App Widget Provider
App Widget Host, Real World Samples
Basic App Widgets
The AppWidgetProviderInfo Class
The App Widget Layout
The onUpdate Method
App Widgets Installation
App Widgets Execution
Configuration Activity
Configuration Activity Role
Launching Configuration Activity
App Widget Provider Role
Developing Configuration Activity
Updating The App Widget
Configuration Activity Returned Value
Design Guidelines
Design Guidelines Importance
Google Android Design Guidelines
Standard App Widget Frames
Drawing Buttons
|
|
flex4lcds3 |
Flex 4 and LiveCycle Data Services 3 |
14 hours |
This training course is aimed at Developers wishing to extend their Flex knowledge using LiveCycle Data Services in Flex applications.
It is a comprehensive 2 day in using LiveCycle Data Services 3 with the Adobe Flex 4 framework. Emphasized topics will include:
Messaging, remoting, and web services
Performance profiling and unit testing
Client-side data manipulation
Model-driven development using the Fiber Framework and Flash Builder 4
Introduction
Course format
Reviewing the course prerequisites
Reviewing the course outline
Accessing Web Services
Using web services
Process for calling web services
Invoking web service methods and using the results
Invoking the methods on a web service
Understanding ArrayCollection class results
Using web service results
Handling results using an event handler
Using the results event handler
Handling faults
Creating fault event handlers
Displaying faults with an Alert pop-up
Calling multiple methods from the same WebService object
Using the <s:operation> tag
Passing parameters to web services
Passing parameters to a web service explicitly
Passing parameters to a web service using parameter binding
Using Remote Object Connections
Introducing LCDS / BlazeDS
Surveying the LCDS feature set
Introducing BlazeDS
Compare and contrast LCDS and Blaze DS
Understanding the Remoting Service
The Remoting Service and AMF
Configuring a Remoting Service destination
Using <s:RemoteObject>
Accessing data from a remote method
Handling RPC events
Handling successful remote calls
Handling faults in remote calls
Complex remote method calls
Handling events of multiple methods
Passing parameters
Type conversion during data transfer between ActionScript and Java
Converting data from Java to ActionScript
Converting data from ActionScript to Java
Converting custom object types
Managing RemoteObject events using AsyncToken
Understanding dynamic classes
Remoting Service Runtime Configuration
Selecting a channel at runtime
Managing Data on the Client
Understanding collection classes
Collection features
Collection interfaces
Specific collection classes
Filtering data on the client
Creating the filter function
Using the function
Sorting data on the client
Understanding the sort classes
Process for sorting data
Simple sorting example
Complex sorting example
Using the IViewCursor interface
Cursor operations
Creating and using the cursor
Code examples
Using the Message Service
Introducing the message service
Creating a messaging destination
Sending messages
Creating a messaging producer
Using the AsyncMessage class
Tracing message traffic
Receiving and processing messages
Creating a messaging consumer
Subscribing and unsubscribing to a destination
Receiving messages
Sending and receiving complex data
Implementing message filtering
Using selectors
Using subtopics
Using Flash Builder Development Tools
Using logging
Logging on the client
Running the debugger
Using breakpoints
Introducing the profiler
Introducing Flash Player garbage collection
Profiling an application
Using memory profiling
Monitoring Flex RPC network traffic
Using the Network Monitor
Developing Applications Using Model Driven Development
Introducing model driven development using LCDS 3
LCDS model driven development benefits
Comparing code- and model-driven development
Preparing to use model driven development
Setup details
Creating and using the data model
Table joins representation in the model
Modeling language
Editing generated ActionScript value objects
Flash Builder functionality for MDD
Adding properties to the model
Creating a derived property
Updating changes to the database schema
Creating a method to calculate a derived property
Using styles in a form
Implementing validation through styles
Using styles to change other form behaviors
Using global styles
Filtering returned data
Implementing a filter
Implementing Advanced Model Driven Development Techniques
Creating conditional properties with variants
Implementing the variant in Flash Builder
Selector expression
Case
Substructure
Using resource bundles for localization
Creating property files
Compiling resources into the application
Selecting a locale
Altering the form generator template
Extracting the client-side templates
Generating the server side Java
|
|
822 |
C#.Net |
35 hours |
Objectives
This C# course will enable delegates to develop applications in the C# programming language. Delegates will be able to program using the principles of object orientation. The course will also cover how to use the Visual Studio 2010 development environment to produce robust and maintainable applications.
Audience
This course is intended for the following types of software developers:
New developers
Developers who understand computer programming but may have learned programming by using a non-graphical language in a university
These developers want to build solutions by using C#; within the Microsoft .NET Framework. They also want to employ Object Orientated techniques to enhance their development skills.
Module 1. Principles of Object Orientation
Creating models
Classes & objects
Encapsulation, specialisation & polymorphism
Module 2. Designing Applications with UML
What Is UML
UML Diagrams
Use Case Diagrams
Class Diagrams
Interaction Diagrams
Module 3. Getting Started with C#
C# and .Net
The C# Language
Visual Studio IDE
Module 4. C# Language Fundamentals
Data Types
Variables
Constants
Strings
Statements
Expressions
Module 5. Branching
Conditional branching statements
Unconditional branching statements
Loops
Module 6. Operators
Assignment
Mathematical operators
Increment & decrement
Relational
Module 7. Classes and Objects
Defining classes
Constructors
Static and instance members
Destroying objects
Module 8. Inside Methods
Overloading methods
Encapsulating data with properties
Returning multiple values
Module 9. Debugging
Setting a breakpoint
The Call stack
Module 10. Inheritance and Polymorphism
Specialisation and generalisation
Inheritance
Polymorphism
Abstract and sealed classes
The root class: object
Boxing and unboxing types
Module 11. Operator Overloading
Using the Operator Keyword
Creating Useful Operators
Logical pairs
Conversion Operators
Module 12. Structs
Defining a Struct
Module 13. Interfaces
Implementing and interface
Implementing more than one interface
Casting to an interface
Extending and interface
Module 14. Arrays
Declaring arrays
Multidimensional arrays
System.Array
Indexers
Module 15. Collection Interfaces and Types
The collection interfaces
Array lists
Queues and stacks
Module 16. Strings
Creating strings
Manipulating strings
The StringBuilder class
Module 17. Throwing and Catching Exceptions
The throw statement
The try and catch statement
How the call stack works
Exception class methods and properties
Module 18. Delegates and Events
Delegates
Events
Module 19. Generics
Generics: A Primer
Parameterizing by data type
System.Collections.Generics class
|
|
dsgpatphp |
Design Patterns in PHP |
14 hours |
The course will cover the design patterns with particular emphasis on patterns used in PHP.
Introduction to Design Patterns
What is a design pattern
Elements of pattern
Advantages and disadvantages of using patterns
GoF Design Patterns
Patterns creative
Builder
Factory (Abstract Factory, Factory Method)
Prototype
Singleton
Structural patterns
Delegator
Interface
Facade
Composite
Immutable
Adapter
Decorator
Proxy
Behavioral patterns
Command
Template method
Observer
Chain of responsibility (oraz Intercepting Filter)
Observer (2 version)
Strategy
Patterns of Enterprise Application Architecture Web
MVC - Model View Controller
HMVC, MVP
Inversion of Control
Dependency Injection Container
Active Record
The concept of entity and Repositories
Decomposition of the system
Examples of component-based Symfony 2 and Zend Framework 2
|
|
golang1 |
Go Programming Language for Programmers |
28 hours |
Solid introduction to Go language for people familiar with other programming languages. It focuses on practical aspect of the language rather than theory.
Go vs other programming languages
Go basic concepts
Variables and Types
Pointers
Functions
Branching and looping
Complex Structures
Maps and Sclices
OOP Concepts (Classes, Interfaces)
Error Handling
Concurency
Concurrency Patters
Common Packages
Go Tools
|
|
AJS-GP |
AngularJS Good Practices |
14 hours |
Angular Bespoke Course Outline
This agenda can be adjusted or extended.
This course is usually for javascript developers with some angularjs basic experience, who want to learn best angularjs practices and also to do their angular applications in better and more organized way.
Avoiding major pitfalls of scaling an AngularJS app
Proper MVC directory structure
Writing Modules in a smarter way
Keeping the names consistent
Modularize the Header, Footer, Routes
Dependency injection and minifying the code
Global dependencies
Not-overusing Controllers
Syntax of 'controllerAs'
Using 'bindToController' in our Directives
Making 'ng-click' conditional
Factory vs Service
All providers are singletons
Utilizing browser extensions (Batarang, etc)
To many watchers and performance issues
Scoping
Write-only in the controllers
Read-only in the templates
Object in the scope instead of properties
Avoiding to shadow property of the parent '$scope'
Prototypical inheritance
Keeping scope uncluttered
How to talk with sibling objects
One-Time Binding
Not-manual testing
ngMock module
Protractor
e2e tests with Jasmine '
$digest' cycles
Karma
How to easly close the feedback loop
Run tests in parallel across different browsers
Real world usage scenarios with different devices
Not-using jQuery
Change the way of thinking
Proper deploying
Facade to interact with servers
Separation of server interaction and error handling from the model
Business logic in models
Configure providers before they are injected
Proper use of '$scope.$emit()' and '$scope.$broadcast'
Automating our workflow
yo, grunt, bower
Use case with cordova
Angular 1 vs Angular 2
Differences and similarities
Three ways: typescript, pure js, dart
Good practices in Angular 2
Upgrading from version 1
|
|
CUDAProg |
NVIDIA GPU Programming |
14 hours |
Day 1 - Introduction and Basics
Why Parallel Computing? Need for parallel Computing
Multi-Core processors - Architecture and Design
Introduction to Threads, Thread Basics and Basic concepts of parallel programming
OpenMP- A Standard for Directive based Parallel Programming
Hands on / Demonstration of various programs on multicore machines
Day 2 - GPU Programming
GPU's for parallel Computing
GPU's Programming Model
Hands on /Demonstration of various programs on GPU
SDK, Toolkit and Installation of environemnt for GPU
Working with various Libraries
Demonstration of GPU and Tools with Sample Programs and OpenACC
|
|
seleniumCsharp |
Selenium WebDriver in C#: Introduction to web testing automation in C# |
14 hours |
This course introduces participants to automated testing with Selenium WebDriver and C# in Visual Studio. If you do not have C# programming experience or wish to brush up on C#, please check out the course: C# for Automation Test Engineers.
Audience
Developers and testers with knowledge of C# who wish to set up automating testing with Selenium
Format of the course
Part lecture, part discussion, heavy hands-on practice, occasional tests to gauge understanding
Introduction
Selenium Automated Web Application Testing
C# and .NET
About Selenium WebDriver
Tools
Unit testing Frameworks
Supported Browsers
Installing and configuring WebDriver with C#, .NET and VisualStudio
Using NuGet
Libraries and extensions
Organizing your file structure
Writing a Nunit Test
Import statements
Invoking the browser
Writing to the console
Identifying UI Elements
Chrome Developer Tools and other extensions
Regular expressions
Index
Xpath functions
Performing user actions in WebDriver
Performing mouse and keyboard operations
Edit boxes, combo boxes, buttons, links, checkboxes and radio buttons
Capturing and validating data from web page
Asserts and execution flow
Other operations
Mouse events
Screenshots
Executing Javascript
Frames, alerts and multiple browser windows
Using C#'s built-in functions
Strings
Date and time
Files and folders
Math operations
Exception handling
C# .Net
Webdriver
Synchronization
Implicit vs Explicit waits
Fluent waits
Working with Page Objects (POM)
Refactoring
Developing a library of pages (POMs)
Testing Structure
Nunit Fixtures, Nunit Traits and Categories, Playlists
Helper Libraries
Data-Driven Testing
Selenium IDE and Selenium Grid
Integration
The future of automation testing |
|
selendroid |
Selendroid: Automated testing for Android |
7 hours |
Selendroid is an open-source test automation framework for Android devices. It can be used to test native applications, hybrid applications and mobile websites running on real devices as well as emulators. Based on the Selenium Webdriver client API, it supports full integration with existing Selenium frameworks. Selendroid supports hot plugging of hardware devices and can be integrated as a node in Selenium Grid for large-scale parallel testing. It is compatible with the JSON Wire Protocol.
This training introduces the Selenium framework and walks participants through the setup, configuration and execution of automation tests in a live hands-on test environment. After the course, participants will have the knowledge and practice to carry out their own automated testing initiatives for Android devices.
Audience
Test engineers
Format of the course
Interactive discussion + heavy hands-on practice
Introduction
Native-mobile, hybrid mobile and web app test automation
Selendroid vs Appium
Overview of the Selendroid architecture components
Selendroid Client, Selendroid Server, AndroidDriver App, Selendroid-Standalone
Setting up a Selendroid testing environment
Choosing between hardware and emulator testing
Running Selendroid-Standalone to manage test devices
Running Selendroid Server for app automation testing
Writing your first test
Executing your first test
Interacting with elements
Using the XML viewer
Using Selendroid Inspector to simplify test case development
Integrating with Selenium Grid for parallel testing
Testing gestures using the Advanced User Interactions API
A note about multi-touch support
Writing tests with other WebDriver-compatible languages (JavaScript, Python, etc.)
Closing remarks |
|
struts2 |
Struts 2 Framework |
21 hours |
This course deals with developing MVC (Model-View-Controller) web application using the features of Struts2 framework. The participants will learn how to work with the actions and the data, how to develop interceptors and the OGNL for type conversion. This course will also cover concepts like validation, internationalization and how to persist data.
Introduction to Struts2
Web applications: a quick study
Why use a framework for web applications
The Struts2 framework and the declarative architecture
The support of annotations
Actions and Interceptors
The role of actions
Implementing and packaging actions
How to dialogue with data
The role of interceptors
Developing and declaring interceptors
The request/response life cycle
OGNL (Object-Graph Navigation Language)
The common tasks in a web application
Data transfer and type conversion
The built-in converters
How to build a custom type converter
How to validate data
The validation framework
Using the built-in rules
Writing a custom validator
Writing the actions for validation
Internationalization
Java i18n and Struts2 framework
How to use Struts2 i18n
The default local determination
Struts2 integration and the persistence layer
Using Spring with Struts2
The concept of injection
Why use the JPA with Struts2
Integrating Struts2 with Hibernate
|
|
androidhybapp |
Android Hybrid Applications |
35 hours |
One of the android platform available user interface control, is the web view. The web view functions as a small web browser and is capable of parsing and displaying data similarly to any web browser. Its implementation is based on the WebKit open source browser. The same engine Chrome and Safari are based on. The methods we can call on a web view object allows us having a smooth integration between the data displayed within the web view and the native part of our application. This integration allows us to enjoy both worlds.
This course focuses on these new types of applications, also known as hybrid applications.
XHTML
CSS
DOM
HTML5
JavaScript
Ajax
jQuery
jQuery Mobile
WebView |
|
asp4 |
ASP.Net 4.0 |
35 hours |
Delegates will be introduced to the .Net framework and will learn to develop web applications using C# 4.0. At course completion delegates should be familiar with the framework, experienced in developing basic web application and conversant with database access using LINQ. Applications will be created using Object Orientated programming.
After completing this course, delegates will be able to:
Use Visual Studio 2010 effectively
Learn C# 4.0
Create commercial ASP.NET Web Applications
Understand OO Programming, Classes, and Objects
Debug Applications
Develop user interfaces using Master Pages, Site Navigation and Themes
Use ADO.Net and LINQ to read from and write to databases
Develop rich internet applications using ASP.NET AJAX
Create and call WCF services
Introducing The .Net 4.0 Framework
Integrated Development Environment (IDE)
Languages In The .Net Framework
The Common Language Runtime (CLR)
Accessing Data With ADO.Net & XML
Accessing The Web With ASP.Net
Visual Studio 2010
Useful Visual Studio Windows
Creating Projects
Project Anatomy
The Files In A Project
Solution Explorer
Code Snippets
C# Language Syntax
Data Types
Variables Declaration
Operators
Conditional Statements
Looping Structures
Classes & Objects
Building Models
Creating Classes And Objects
Adding Constructors To A Class
Adding Methods, Properties And Events
Overloading Methods
Property Procedures
Debugging Applications
Setting Breakpoints
Stepping Through Code
Debug Windows
Watch Windows
Call Stack
ASP.Net Introduction
Starting An ASP.Net Project
Project Files
Server Controls
Server Event Handling
The Page Lifecycle
User Interface Development
Master Pages
Themes And Skins
User Controls
Website Navigation
Validation Controls
Module 8: Configuration
Website Configuration Settings
Configuration Files Including The Web.Config Files
Storing Application Settings And Configuration Strings
The Website Administration Tool
Membership & Personalisation
Securing And Personalizing A Website
Store User Details In The Membership Database
Using Login Controls
Website State Management Methods
Using Viewstate To Store The State Of A Page
Exception Handling
Adding Try Catch Blocks To Code
Page Level Exceptions
Site Level Exceptions
Custom Error Pages
Tracing
Data Access
What Is ADO.Net
Connection Object
Command Object
Data Readers
Datasets And Data adapters
Using The Datasource Wizard
Creating Responsive Pages With AJAX
AJAX Architecture
What Are Partial-Page Updates
Using The Updatepanel Server Control
Using Client-Side Scripts
Data Access With LINQ
Why Do We Need LINQ
Querying The Database
Language Syntax For Querying
Using The LINQ To SQL
Using Windows Communication Foundation (WCF) Services
Service Orientated Architecture
WCF Scenarios
Mechanics Of Communication: Address, Contract, Binding
Creating A Simple WCF Service
Calling A WCF Service From A Client Application
Deployment
How To Deploy A Web Application
Deployments Methods
Using Visual Studios Copy And Publish Tools
Using Setup Projects
Installing Assemblies In The GAC
|
|
androidappdev |
Develop Android Applications |
21 hours |
This course has been created for everyone interested in creating Android applications.
During this course, you will learn the fundamental skills required for building Android applications from scratch using interesting features added to the Android platform, like background processing, database access and location-Based Services.
Introduction to Android
Android SDK Features
Introducing the Development Framework
The Dalvik Virtual Machine
Android Application Architecture
Downloading and Installing the Android SDK
An Android Application
Creating a New Android Project
Creating an Android Virtual Device
Foreground and Background Applications
The Android Emulator
Applications and Activities
Introducing the Application Manifest File
Using Resources
The Android Application Lifecycle
Understanding an Application’s Priority and Its Process’ States
Creating Activities and the Activity Lifecycle
Fundamental Android UI Design
Defining Layouts
Creating New Fragments
The Android Widget Toolbox
Introducing Adapters
Defining and Using Styles
Elements of Style
Where to Apply a Style
The Available Attributes
Inheriting a Style
Using Intents and Broadcast Receivers
Using Intents to Launch Activities
Using Intents to Broadcast Events
Creating Intent Filters and Broadcast Receivers
Listening for Native Broadcast Intents
Monitoring Device State Changes Using Broadcast Intents
Using Internet Resources
Connecting to an Internet Resource
Using the Download Manager
Using Internet Services
Using File, Saving State, and Preferences
Creating and Saving Shared Preferences
Retrieving Shared Preferences
Introducing the Preference Framework and the Preference Activity
Including Static Files as Resources
Working with the File System
Databases and Content Providers
Introducing Android Databases
Introducing SQLite
Content Values and Cursors
Working with SQLite Databases
Querying a Database
Creating Content Providers
Using Content Providers
Working in the background
Introducing Services
Binding Services to Activities
Using Background Threads
Using AsyncTask to Run Asynchronous Tasks
Using Alarms
How to notify events
Introducing the Action Bar
Creating and Using Menus and Action Bar Action Items
Introducing Dialogs
Introducing the Notification Manager
Creating Notifications
Geocoding and Location-Based Services
Using Location-Based Services
Using the Emulator with Location-Based Services
Selecting a Location Provider
Finding Your Current Location
Using Proximity Alerts
Creating Map-Based Activities
|
|
css3int |
Introduction to CSS3 |
7 hours |
The course provides an introduction to the latest standard CSS (Cascading Style Sheets). We will present new elements of style sheets, providing greater opportunities for formatting and the current level of support for standard browsers.
Introduction to CSS
What is CSS
CSS capabilities and applications
CSS history
CSS3
new CSS3 standard elements
support from different browsers
media
selectors
pseudo classes / components
text - styling, effects, use of web fonts
color, transparency, gradient
background images and Decoration
transformations
animation
distribution management (columns, box layout, template layout)
Future extension of CSS3 |
|
ngandv |
AngularJS Advanced |
21 hours |
This course has been created for developers working with AngularJS, but who want to understand clearly best practises of using the framework. It doesn't cover the basics of angular but focuses on methods and styles of developing SPA usually not easy to learn "naturally" or via self-study.
This course usually runs on the latest stable release of Angular (1.x), but older or beta version can be covered on demand.
Super Short Introduction
Binding Variables
Build-in directives and their scope
Data entry
Scope and rootScope
Collections
Controllers
Services
Filters
Angular Patterns
Factories
Services
IoC
MVC in depth
Angular MVC
Fat controler vs fat model and consequences
Creating own controllers
Different ways of dependency injections
Minifying and consequences of using paramer names
Routing
Creating menus
Modifying url
HTML5 history object
Directive Development
creating own directives
managing associated controlers
creating own module with directives
animation controls in custom directives
REST Services
Using web services
Ajax
Animation
Angular and CSS3
ngAnimate
Mobile Design in Agnular
Responsible
Separate version fo mobile
Testing
Unit Testing
Available frameworks
Karma
Testing Controllers
Dependency Injection in testing
BDD Testing
Available frameworks
Jasmine
E2E (End to End Testing) testing
WebdriverJS
Protractor
Continous Integration with Angular
Bigger enviornment
Backend interactions with MEAN stack
Node.js
Express.js
MongoDB
Streaming with gulpjs
|
|
ipmat1 |
Introduction to Image Processing using Matlab |
28 hours |
This four day course provides image processing foundations using Matlab. You will practise how to change and enhance images and even extract patterns from the images. You will also learn how to build 2D filters and apply them on the images.
Examples and exercises demonstrate the use of appropriate Matlab and Image Processing Toolbox functionality throughout the analysis process.
Day 1:
Loading images
Dealing with RGB components of the image
Saving the new images
Gray scale images
Binary images
Masks
Day 2:
Analyzing images interactively
Removing noise
Aligning images and creating a panoramic scene
Detecting lines and circles in an image
Day 3:
Image histogram
Creating and applying 2D filters
Segmenting object edges
Segmenting objects based on their color and texture
Day 4
Performing batch analysis over sets of images
Segmenting objects based on their shape using morphological operations
Measuring shape properties
|
|
pjruby |
Ruby Programming |
21 hours |
The course is intended for developers who are familiar with any other procedural or structural language (eg. C, Pascal, C ++, Delphi). During the training participants will learn how it is built into Ruby, how to install the Ruby interpreter and the most important tools to write basic applications. The course also introduces the object-oriented programming and functional.
Introduction to Ruby
History Ruby
Area of use
Key features of the language
Supported programming paradigms
Ruby Tools
Overview editors and IDE
Interpreter Ruby
IRB
Gem Packages
Rake
Basic language constructs
Keywords language
Fixed variables, types
Operators
Control Statements
Functional Programming
Functions, arguments, return values
Lambda
Closures
Recursion
Lazy evaluation
Higher-order functions
Object-Oriented Programming
Overview paradigm
Classes and Objects
Inheritance, encapsulation, abstraction, polymorphism
Constructors
Accessor
Modules
Mixed class
Error handling exceptions
The most important class predefined Ruby
Specific features of the language
Control Statements
Symbol
Compartments
Poetic mode
Practical application
Applications supporting system administration
Network Applications
Web Applications
|
|
Csharpfortesters |
C# for Automation Test Engineers |
21 hours |
This course is designed for anyone interested in learning C# for the purpose of automation testing. It is a streamlined, intensive course with plenty of hands-on exercises to get participants ramped up quickly with the essential programming skills needed to apply in software automation testing. The focus is on the C# fundamentals which can be directly and immediately applied to test automation.
This course does not cover in depth test automation frameworks such as Selenium. If you are already versed in C# and wish to get straight into testing with Selenium, please check out: Selenium WebDriver in C#: Introduction to web testing automation in C#.
Audience
This course is intended for beginner testers who wish to learn C# for automation testing as well as for professional testers with experience in other programming language such as Java or Javascript who wish to transfer their testing skill set to C#.
Format of the course
Part lecture, part discussion, heavy hands-on practice, occasional tests to gauge understanding
Project setup
.Net and VisualStudio setup
C# data types and operators
Variable types
Operators
Conditional statements
Loop Statements
Lists
Switches
Arrays
Object-oriented programming
Class creation
Constructors
Constructor overloading
Namespaces and using statements
Methods
Method creation
Method reuse
Method overloading
Passing arguments
Containers
ArrayLists
Vectors
HashTables
Generics
Extending classes
Construction of classes
Inheritance
Polymorphism
Abstract classes
Interface classes
Working with strings
Manipulation
Formatting
Tokenizers
Unit tests
Web testing
Creation
Assertions
Debugging
The Watch Window
Debug Commands
Debugging Functions
Exception Handling
Catch Block
Finally Block
Throw Keyword
Try Catch Block
Working with JSON
Structure
JSON libraries
Creating JSON strings
Deserializing
Towards an Automation Framework
Closing remarks |
|
springboot |
Spring Boot: Rapidly build Spring-based web applications |
14 hours |
Spring Boot is a Java-based web application development framework that favors convention over configuration. Spring Boot allows developers to create stand-alone, production-grade applications that "just run", typically on an embedded instance of Tomcat, Jetty, or Undertow.
Spring Boot's "opinionated view" of the Spring platform and third-party libraries allows for minimum-fuss application development that requires very little configuration. These Spring Boot applications require no code generation or XML configuration. They feature integrated health monitoring, simplified Maven configuration, and a host of other features that make building, deploying, and running Spring applications relatively straightforward.
In this training, participants learn the key features and architecture of Spring Boot, its relationship to the underlying Spring framework, and how it compares to other Spring-based frameworks. Particpants get ample opportunity to test usage scenarios, discuss and receive feedback as they step through live, hands-on exercises on defining, configuring and deploying Spring applications. By the end of the course participants will have the necessary knowledge and practice to rapidly deploy their own Spring application.
Audience
Java web application developers
Format of the course
Heavy emphasis on hands-on practice. Most of the concepts are learned through samples, exercises and hands-on development.
Introduction
Spring Framework: from 2002 to now
Spring Boot: building on top of the Spring framework
Spring Boot architecture and fundamentals
Overview of MVC
Initializing your project in Eclipse
Using Groovy to script Spring Boot
Using Spring Boot CLI
Building and deploying an application
Using templates to serve up dynamic HTML
Running Spring Boot application starters
Accessing data with Spring Data
Configuring Spring Boot properties
Spring Boot metrics and health checks
Securing your application with Spring Security
Authentication and authorization
Interacting with a JMS broker
Closing remarks |
|
javafun |
Java Fundamentals |
28 hours |
The course covers the basics of Java development.
It introduces students to Java technology and teaches them basic Java syntax and concepts, leading to the creation of a simple program. Training goes through the essential concepts and features of the Java Programming Language, focusing on exceptions, basic input/output, concurrency, regular expressions, Java collections framework and the platform environment. The course finishes when all basic Java features have been explained and trained.
Getting Started
The Java Technology Phenomenon
How to write basic "hello world" application
How to compile and execute Java code
How to make the code a bit more complex
Java Syntax
Object-Oriented Programming Concepts
Variables, arrays, data types, operators, and control flow
What are reference variables
Classes and objects
What inheritance is and how it works
What Interfaces are, why they are written and how
How to use Java String and Number objects and how to format data for output
What packages are for and why we must use import directive
Java Objects
Java classes overview
Java class life cycle
Class modifiers and inheritance
Overloading" and overriding
Class constructors
Polymorphism
Relationships: IS and HAS
'static' keyword
When to use static members
Java Collections
Collection interface
Lists, maps and sets
Collections and arrays
Concurrency
Java Memory
Garbage collector
Heap and stack
Object life cycle
'finalize()' method
Java Exceptions
The general idea of Java Exceptions
Runtime and 'real' exceptions
Throwing an exception
'try...catch' statements
'throws' declaration
Designing your own exceptions
Java Concurrency
Threads and concurrency
Threaded tasks
Joining threads
Class variables visibility
|
|
as3 |
ActionScript 3.0 Programming |
21 hours |
This course deals with developing graphical parts of a web application using ActionScript. The participants will learn how to use the powerful features of the new ActionScript 3.0, programming with object oriented, managing the interactivity part of the application and using the API to display graphics.
Core Concepts
Datatypes and type checking
Conditional and loops
Instance members, static members and functions
Inheritance and Interfaces
Managing Arrays
Exceptions and Error Handling
Interactivity
The Display API and the Display List
Events and Display Hierarchies
Interactivity with mouse, focus, keyboard, .. events
How to manage screen updates
Scheduled and post-event screen updates
Animation with code
The ENTER_FRAME and TIMER event
Display
Drawing with vectors
Drawing lines, curves, shapes
Programming with bitmap
The BitmapData and Bitmap Classes
Creating and loading a bitmap image
Applying filters and effects
Creating and displaying text
Loading External Display Asset
Applied ActionScript
ActionScript and the Flash Authoring Tool
Symbols and instances
Linked classes for movie clip symbols
Accessing created symbol instances
Programmatic timeline control
Preloading classes
Distributing a class library as a .swc file
Distributing a class library as a .swf file
|
|
javafunandroid |
Java Fundamentals for Android |
14 hours |
Applications for the Android platform are developed primarily in Java. This course was developed for software programmers with a strong OOP background (whether in PHP, Scala, C++, C# or Objective C) that plan to learn how to develop Java applications for the android platform. This course covers the Java programming language grammar and focuses on those specific Java capabilities the android platform uses more than others.
Let's Start
History
JVM
JDK
JRE
Hello World
JavaDoc
Classes & Packages
API Documentation
The Basic
Java comparing with C++
Simple Output
Remarks
Native Data Types
Variables
Keywords
Identifiers
Expressions & Operators
Simple & Compound Statements
Control Statements
Looping Statements
Assignments
Local Variables
Assertion
Annotations
Introduction to OOP
Software Development Cycle
Objects & Classes
Key Features of OOP
Relationships between Objects
Object Oriented Programming
Objects Classes & Class Type Variables
Declaring Classes, Class Type Variables
Calling a Method
The 'this' Special Keyword
Class Declaration
Declaring Attributes
Declaring Methods
Methods Overloading
Declaring Constructors
Default Constructors
Overloading Constructors
Using 'this' within Constructors
Static Variables
Static Methods
Static Initializers
Final Variables
Software Packages
Package Statement
The 'import' Statement
Declaring Enums
Java API Documentation
Arrays & Strings
Array of Native Type Values
Array of Objects
Square Brackets Position
Copying Array Values
Multi Dimensional Array
The 'length' Variable
The 'String' Class
Instantiating String
Comparing Strings
The 'toString()' Method
The StringBuffer Class
The StringBuilder Class
The StringTokenizer Class
Passing Arguments to 'main' Method
Inheritance
Introduction to Inheritance
Inheritance in Java
Derivation Syntax
Inheritance Meaning
Constructors & Inheritance
Access Modifiers
Overriding Methods
Polymorphism
Constructors & 'super' Keyword
Abstract Class
Interfaces
The 'instanceof' Operator
Casting References
Deprecated Methods
The 'object' Class
Inner Classes
Inner Classes Types
In-Depth Meaning
Inner Classes within Methods
Anonymous Inner Class
Static Inner Class
Exceptions Handling
The Exceptions Handling Mechanism
Exceptions Classes Hierarchy
Three Types of Exceptions
Try&Catch Statement
The 'throw' Command
The Throwing Chain
The 'finally' Block
The 'throws' Adding
The 'Handle or Declare' Rule
Methods Overloading, Samples
Threads Basics
What is a Thread?
The Thread Parts
Creating New Thread
Starting The Thread
Multiple Threads
I/O Streams
Java I/O Overview
I/O Streams Categories
Byte & Char Streams
The InputStream Abstract Class
The OutputStream Abstract Class
Writing/Reading To/From Files
Generics
Introduction
Subtypes
Wildcards
Collections
Introduction
Performance
Set
List
Queue
Map
|
|
luacomp |
Comprehensive Lua |
21 hours |
Lua is an easy to use scripting language that is used as an embedded plugin/extension language in different products. For example it is the embedded scripting language of network applications like nmap and wireshark, and can also be found as a scripting language in World of Warcraft, Orbiter and other games.
Lua can also be used as a standalone language. It is a lightweight, multi-paradigm programming language and therefore the course teaches various concepts that students will find useful in other areas of software engineering as well.
This course covers everything out there to know about Lua. We build up from the basic programming constructs, learn about advanced techniques and finally talk about embedding of Lua into other programming languages and embedding other programming languages into Lua. The course contains a lot of programming exercises, so that newcomers can gain proficiency with the language, starting from scratch.
Introduction to Lua
A bit of history
Lua's goals, features and non-goals
Resources of Lua documentation and tutorials
Installing the Lua interpreter
Setting up and using LuaRocks
Basic syntax and semantics
Identifiers
Comments, block comments
Global variables and enforcing of strictness
Local variables
Standalone programs, program arguments
Compilation units, chunks, expressions, semicolons
Data types and data structures
Basic types: nil, boolean, number, string
Object types: function, userdata, thread, table
References/objects vs. basic values
The importance of tables in Lua
Introduction to tables and their versatility
Tables as an associative array
Tables as numeric arrays, sequences
Basic control structures
The if then elseif else end
The while loop
The repeat loop
The simple for loop
Error handling
Return values vs exceptions
Converting a return value to an exception
Converting an exception to a return value
Error levels
Example programs
Polynomial evaluation
Breadth first search
Additional exercises
More about functions
Named arguments
Object-oriented calls
Closures
Currying
Tail calls
Multiple assignment and return
Varargs
Iterators and co-routines
The generic for loop
Stateless vs stateful iterators
Differences between iterators and co-routines
Metatables and metamethods
The set example
The __tostring metamethod
Arithmetic metamethods
The __index, __newindex metamethods
The __len metamethod
Modules and packages
Using modules
Creating modules
Organizing modules into packages
Advanced tables
Tables for queues and stacks
Tables describing graphs
Matrices as tables
Linked lists as tables
String buffers
Metatables through examples
Proxies
Readonly
Memoization
Dynamic programming with memoization
The Fibonacci example
Environments
Relationship between global variables and environments
Free variables
The _ENV table and the _G table
More about modules
Different approaches to creating modules
Modules that change the behavior
Module initialization and arguments
Using environments to implement safe modules
Advanced iterators and co-routines
Producer, consumer, filter
Wrapping co-routines to get iterators
Stateless iterator for linked lists
Contributing to the Ecosystem
Uploading packages to MoonRocks
Functional paradigm in Lua
The map function
The reduce / fold function
Object-oriented Programming
Different approaches to OOP
Different approaches to inheritance
Examples
A walkthrough of the Lua Standard Libraries
Compilation
Compilation
Eval
Relationship with the environment
Binary chunks
Garbage collection
Weak tables
Finalizers, the __gc meta-method
Lua bytecode and virtual machine
Generating bytecode from source code
Reading and analyzing bytecode
Quick tour of the source code of the Lua VM
C modules
Calling C from Lua
Search path and loading of C modules
Calling Lua from C
The Stack
Error handling
Continuations
Handling Lua values and types from C
Arrays
Strings
Userdata
Metatables
Object oriented calls
Light userdata
Memory management
Allocators
GC API
Threads in Lua
Co-routines vs threads
Real multi-threading and Lua states
|
|
matlabprog |
MATLAB Programming |
14 hours |
This two-day course provides a comprehensive introduction to the MATLAB® technical computing environment. The course is intended for beginner users and those looking for a review. No prior programming experience or knowledge of MATLAB is assumed. Themes of data analysis, visualization, modeling, and programming are explored throughout the course.
Working with the MATLAB user interface
Entering commands and creating variables
Analyzing vectors and matrices
Working with data types
Automating commands with scripts
Writing programs with logic and flow control
Writing functions
Visualizing vector and matrix data
Working with data files
Importing data
Organizing data
Visualizing data
|
|
gfadm |
GlassFish Administration |
21 hours |
GlassFish Administration Training introduces participants to the secrets of the installation, configuration, management, monitoring GlassFish server. Training is open to future GlassFish server administrators.
Introduction and Installation GlassFish
Overview and architecture of Java EE
GlassFish White
Basic GlassFish Architecture
Download and install GlassFish
Starting and Stopping the GlassFish
Structure and architecture
File structure
Server profiles, domains, and configuration
Configuration Files - Setup.xml and domain.xml
Login and login configuration
The Admin Console
The asadmin Command Line Interface
Deployment
The structure of the Java EE Application (Jars, Wars, Ears, Sars)
GlassFish Deployment Details
Deploying with the Admin Console and asadmin
Deploying Using autodeploy
Deploying with asant Tasks
Directory (Expanded) Deployments
GlassFish Classloading, and Effect on Deployment
Configuration Services (Web, JNDI, Datasource, EJB, Web Service)
Web Container Overview
Configuring the Web Container / HTTP Service
Virtual Hosts and Listeners
JNDI and Naming Overview
Configuration GlassFish Naming
Configuration klienta JNDI
Review DataSource i JCA
Configuration DataSource i Connection Pool
Container EJB
EJB Pooling and Caching
Container Management EJB
Web Service Overview and Deployment
Viewing, Monitoring, and Managing Web Services
Messaging
JMS - Java Message Service Overview
GlassFish Messaging Overview - Sun Message Queue
Creating Connection Factories and Destinations (Queue/Topic)
Configuring the JMS Provider
Safety
Overview Java security EE
GlassFish Security Architecture
Manage Users, Groups
file, JDBC, LDAP, and other Realms
Password security - password encryption, Master and adminstracja password
SSL / TLS and HTTPS Overview
Configuring and Using GlassFish keytool
Security other sites
Monitoring and Tuning GlassFish
Monitoring
Tuning
Clustering
GlassFish Clustering Overview
Cluster Configuration
The Repository, Cluster Instances, and the DAS
Clustering Architecture (Client Interceptor, Load Balancing and Fault Tolerance, State Replication)
Clustered Services
Load Balancers and Clustered Http
Configuring Apache httpd for Use with the Load Balancer
Conclusions |
|
hhvmadm |
Administering and Optimizing HipHop Virtual Machine (HHVM) |
14 hours |
This course focuses how to install, configure and optimize HipHop Virtual Machine (HHVM). Usually it uses Ubuntu/Apache stack, but can be also adjusted to Windows and other environments.Quick overview of HHVM
JIT
Transcompiler
Community
Installation
Installing hhvm
Installing and configuring Apache/Nginx as proxy
Choosing running strategy
Proxy
Standalone
Daemon
Server
Troubleshooting
Stacktraces
Automatically renewing after crash
Optimization
Basic parameters options
Multiple hhvm servers versus one
Socket vs ports
Monitoring
Profiling (xhprof)
|
|
ansices |
Ansi C for Embedded Systems |
14 hours |
C programming with a focus on how to use it for Embedded System Developments.
C Basic data types
Integer types
Floating point types
Pointers (pointer arithmetic, pointer derefencing)
Arrays
The relationship between arrays and pointers
Enums
Programming constructs
if - else statements
switch statements
while loops and do - while loops
for loops
goto statements
Functions in C
Function prototypes
Understanding C's call by value mechanism for passing arguments
Implementing functions
Calling functions
Using pointers to pass values by reference
Passing arrays to functions
Understanding C's return value mechanism
Using pointers to return values by reference
Data Structures
Defining data structures
Accessing and manipulating the elements of a data structure
Pointers to data structures
The arrow (->) operator
Using a pointer to traverse an array of data structures
Advanced topics
Pointers to pointers
Function pointers
Const and static keywords - their meanings and uses
Casts and casting Using void * pointers
Data structures containing pointers to data structures
Data structures containing function pointers
Function pointers and table driven programming
Bit fields in data structures
Unions
Using arrays to implement circular buffers and stacks
Modules as data structures and interfaces
Dynamic data structures and their uses
Singly linked lists
Doubly linked lists
Overview of the C standard library
putc, putchar, getc, getchar
printf, scanf
String manipulation functions ( strcpy, strcat, ... ) Embedded System Oriented Topics
Setting up port addresses
Defining bit oriented data structures
Compiler specific features
#pragmas
Non ANSII C extensions
Accessing and manipulating special function registers
Implementing interrupt handlers
Calling assembly code from C
Calling C from assembly code
Linkers and linker scripts
Understanding target peripheral device libraries and their uses
Implementing your own device libraries
Timers and their uses
Hardware timers
Software timers
Basics of event driven programming
Port I/O - flashing LEDs
Software delays
Keypad scanning
Basic RS232
Basic data acquisition and sensor interfacing
Working with EEPROM (on chip and SPI/I2C)
|
|
yii2 |
Develop Web Applications with PHP and Yii 2 |
14 hours |
Yii is a high-performance PHP framework best for developing Web 2.0 applications.
Introduction to Yii 2
Installing Yii 2
My first app
Yii 2 project structure
Configuration
Models
Views
Controllers
Widgets and other
MVC and Requests
MVC
Requests
Routing
Sessions and Cookies
Data Access
Data Access Objects
Active Record
Query Builder
Migrations
Getting Data
Forms
Validation
Displaying data
Data Presentation
Sorting
Paging
Data Providers
Security
Authentication
Authorization
Cryptography
REST
Resources, Controllers, Routing
Authentication, Response Formatting, Versioning, Rate Limits
Testing
Testing Environment Setup
Unit Testing
|
|
jenkins |
Jenkins: Continuous integration for Agile development |
14 hours |
Jenkins is an open-source continuous integration tool written in Java. It is a server-based system that runs in a servlet container such as Apache Tomcat. Jenkins supports a number of Software Configuration Management (SCM) tools, including CVS, Subversion, Git, Perforce, and Clearcase, among others. It is highly scriptable and provides support for Apache Ant, Apache Maven, shell scripts, and Windows batch commands.
This course covers the concepts, tools and techniques needed to carry out continuous integration of your software projects in an Agile environment. Participants carry out a series of hands-on exercises throughout the course to apply their knowledge in real situations. Interaction among instructor and participants is encouraged. Real-world cases are discussed and specific issues and questions are addressed and resolved in class.
Audience
Build engineers
Software developers involved in agile development
QA engineers
Project managers
Release managers
Format of the course
Part lecture, part discussion, heavy hands-on practice
Introduction to Jenkins
Why continuous integration?
Distributing builds across different systems.
Setting up Jenkins
Installing Jenkins plugins
Building with Jenkins
Testing with Jenkins
Deploying with Jenkins
Automating with Jenkins
Securing Jenkins
Best practices for Jenkins
Reporting in Jenkins
Closing remarks |
|
cakephp |
CakePHP: Rapid web application development |
28 hours |
This course teaches PHP developers how to build functional web applications using the popular CakePHP MVC web development framework. The course covers beginning principles and approaches, then moves into advanced topics that help enhance the behavior, flexibility and security of an application. Discussions are interactive and the learning is practical and hands-on.
Audience
Web developers wishing to develop better web applications more rapidly
Format of the course
Overview of CakePHP features and capabilities together with step-by-step development of a sample application.
Introduction
Why CakePHP?
Understanding MVC (Model View Controller)
Installing CakePHP
Creating your first CakePHP application
Controller: Controlling the logic flow in your CakePHP application
Model: Modeling your data in CakePHP
ORM (Object Relational Mapping): Mapping table relationships
View: Creating the user interface for your CakePHP application
Baking your CakePHP application
Setting up user authentication
Creating and using components
Adding SEO functionality
Optimizing your application
Debugging your application
Data validation
Error and exception handling
Unit testing your code
Customizing the View to improve the user experience
Configuring Helpers in the presentation layer
Adding support for I18N (internationalization) and L10N (localization)
Implementing Javascript and Ajax features
Tracking application changes with the Events System
Enhancing the Model using Behaviors
Changing your database scheme using the Migrations plug-in
Routing in CakePHP
Creating your own APIs for REST, authentication, etc.
Caching and optimization
Deploying your web application
Migrating existing websites to CakePHP
Closing remarks |
|
Watir |
Watir: Web test automation with Ruby |
21 hours |
Watir (Web Application Testing in Ruby) is an open source library for automating tests. Watir interacts with a browser the same way people do: clicking links, filling out forms and validating text. Based on the WebDriver framework, it is comparable to Selenium and is one of the most popular tools for web application test automation.
In this training participants will learn how to use Watir to automate their web application testing by combining theory with practice in a live lab environment. By the end of the course, participants will have the knowledge and practice to utilize the full power of Watir and Ruby to automate their web testing projects.
Audience
Automation test engineers
Format of the course
An instructor-led course with theoretical coverage of Watir and Ruby together with exercises and a large component of hands-on practice.
Introduction to Watir and Ruby
Installation and setup
Overview of Watir architecture
Ruby scripting for test automation
Working with Webdrivers
Working with Page Objects
Locating page elements
Creating a unit test
Using Watir methods and classes
Accessing a database
Developing a test framework
Troubleshooting
Closing remarks |
|
phpdev |
Developing Websites with PHP |
14 hours |
This course deals with developing web applications in PHP. The course has be created for people already familiar with other procedural programming languages. During the course participants will learn how to create a simple dynamic application with PHP and a MySQL database.
PHP Language Syntax and Basic Concepts
PHP Install and Libraries
PHP Syntax
PHP Variables
PHP String
PHP Operators
If...Else, Switch
Arrays
While Loops
For Loops
Functions
Forms
forms feedback, GET and POST
PHP Include
Data Structures
associative arrays
session variables, global variables, cookies
Date>
File and File Upload
Cookies and Sessions
E-mail
Error Handling
Exceptions Handling
PHP Filter
Object Oriented Programming (OOP)
classes
access modifiers
constructors
inheritance
Using Databases
connect to the database
storing passwords
executing queries
processing data
modifying and removing data
binding form to records in the database
Security
authorization and authentication
using cookies and sessions
Dealing with Images
GD Library and alternatives
PHP XML
SimpleXML
Expat Parser
XML DOM
|
|
posh |
PowerShell Master Class |
21 hours |
To learn the fundamentals of PowerShell from the command line and via scripts
To take a deep dive in to the underlying technologies in use with PowerShell
To learn how to automate common operations using PowerShell
We will look at PowerShell in Windows and in Windows Servers such as SQL, Exchange and System Center
Overview
PowerShell and The Holy Trinity
Discovery
Formatting
Remoting
Providers
Scripting concepts
Modules
.NET, WMI and COM Objects
PowerShell and Windows Server/Client
PowerShell in Key Microsoft Servers
Taking it to the Next Level
The Basics
Discovery – finding your way and discovering more
Formatting – how to format output nicely
Remoting – working with remote systems
Providers – getting into OS data stores
Diving Deep
Scripting Concepts – automating everyday tasks including language constructs, error handling and debugging
Modules – managing PowerShell in the enterprise
.NET/WMI/COM objects – working with objects
Practical PowerShell
PowerShell and Windows Client/Server – how you can use built in PowerShell cmdlets
PowerShell in Key Microsoft Servers - a look at PowerShell today in SQL, SCVMM plus a look forward to the future with SharePoint 2010
Taking it to the Next Level – the stuff we can’t cover in these three days
PowerShell Fundaments – the key elements of PowerShell plus installation, setup, profiles
|
|
androidprog |
Android Effective Programming |
14 hours |
The android platform targets various handsets of different screen size and different capabilities.
This course overviews the recommended practices based on android applications developers experience and based on the official guidelines published by the google android team.
Introduction
User Interface
Performance
Responsiveness
Seamlessness
Architecture |
|
advnet2dev |
Advanced Foundations of .NET 2.0 Development |
21 hours |
Objectives
Improve the security of .NET Framework applications by using the .NET Framework 2.0 security features.
Implement interoperability, reflection, and mailing functionality in a .NET Framework application.
Implement globalization, drawing, and text manipulation functionality in a .NET Framework application.
Audience
The audience for this course consists of Application Developers with the skills to develop business applications by using Visual Studio 2005 with either Visual Basic .NET or Visual C#.
Creating Globalized Applications
Culture Information by Using Globalization Classes
Creating a Custom Culture
Working with Primary Encoding Classes
Working with Advanced Encoding Classes
Working with GDI+ in Windows-based Applications
Working with Graphics, Brushes, Pens, Colors, and Fonts
Manipulating the Shapes and Sizes of Graphical Objects
Working with Images, Bitmaps, and Icons
Implementing Code Access Security
Configuring Code Access Security
Managing Security Policy
Managing Permissions
Managing Access Control
Managing User Identity Information
Implementing Cryptography
Encrypting Data
Hashing Data
Extending the Cryptographic Behavior
Interoperating Between COM Components and Assemblies
Accessing COM Components by Using Interop Services
Exposing an Assembly to COM Components by Using Interop Services
Accessing COM Components by Using Platform Invocation Services
Working with Service Applications and E-mail Messages
Working with a Windows Service Application
Working with E-mail Messages
Working with Type Metadata
Working with Type Metadata by Using Pre-defined Assembly Classes
Working with Assemblies Dynamically by Using Custom Classes
Creating Multithreaded Applications and Application Domains
Managing Threads in a Synchronous Environment
Synchronizing Threads
Managing Threads in an Asynchronous Environment
Working with Application Domains
|
|
gitcomp |
Comprehensive Git |
21 hours |
This is a comprehensive course for people not familiar with any other distributed version control system. It starts with simple exercises for working in a local repository and finishes with practising working in a team.
This course focuses on exercises.
Git Basics
Introduction to Git
Git Repository
Recording Changes to the Repository
Viewing the Commit History
Undoing Things
Tagging
Git Branching
Branching and Merging
Brance Management
Branching Workflows
Remote Branches
Rebasing
Git on the Server
The Protocols
Getting Git on a Server
Generating SSH Public Key
Setting up the Server
Public Access
Hosted Git (GitHUB)
Working with Remotes
Distributed Git
Distributed Workflows
Contributing to a Project
Maintaining a Project
Git Tools
Revision Selection
Interactive Staging
Rewriting History
Debugging with Git (bisect)
Submodules
Subtree Merging
Customizing Git
Git Configuration
Git Attributes
Git Hooks
|
|
3245 |
Android - The Basics |
28 hours |
Android System Architecture. Operating environment
Discussion of the overall architecture of the system Android (Linux kernel, core libraries, JVM, etc.)
Preparation of the working environment (Eclipse + Android SDK). Methods of debugging the program. Discussion of tools such as adb, draw9patch, DDMS, emulator, etc.
Activity life cycle. Implementation and performance analysis methods onCreate, onStart, OnResume, OnPause, OnDestroy.
Data structure design androidowego (src directories, res, xml file AndroidManifest.xml, permissions)
The rules for creating layouts. Examples of Linear-class implementation, Frame-, table-, RelativeLayout.
Implementation loading layouts from XML files and from within the application. Gravity class.
Create menus and dialogs. Implementation and event handling class menu and classes that inherit the dialogue.
Support graphics and touch interface
Review and implementation of the View class methods and drawable.
Gestures - touch event processing. The implementation class methods TouchEvent
implementation of the basic 'building blocks' of the software for Android. Implementation classes TextView, Button, Checkbox, ListView, etc.)
Notification class implementation
Access to the other activities and services running in the background, multithreading
Intent class overview - what it does.
Running other activities. Implementation of the method startActivity () and onActivityResult ().
Starting and communication services operating in the background. Discussion and implementation methods of the class Service.
broadcasts
Threads and Multithreading. Implementation AsyncTask class.
Synchronization. Implementation synchronize blocks and synchronized methods.
Service Location
The basic theoretical information about GPS, WGS84, digital maps (GoogleMaps, OpenStreetMap, BingMaps, etc.)
Event handling GPS. Implementation LocationListener class methods.
Drawing icons and objects on the map.
Extracting the coordinates of the click on the map.
Other
Service settings are stored on the device. Class Preferences.
Access to remote network services. Implementation classes HttpPost / HttpGet.
parsing data structures in XML and JSON. Read and write files on the device.
SQLite CONTENTMANAGER.
Sensors, Cameras, OpenGL.
|
|
plcladder |
PLC Ladder Programming |
14 hours |
Automation Engineers,
Passionates who would like to create their own intelligent home etc.PLC Basics and overview of applications with PLC
Overview of PLC programming languages (Ladder, SFC, C)
Simple Ladder programming
Coils, Inputs, Outputs
Working with memory
Logical functions
Advanced functionality
Sample programming - exercises
PLC and Networking |
|
ecadpap |
Embedded C Application Design Principles for Automotive Professionals |
14 hours |
A two day course covering all design principles with code examples coupled with recent industurial technology; very useful for automotive software developers
What is design?
Design tools overview
Defining design goals
Software Engineering Challenges
Reusablility
Maintainability
Testability
Configurability
Abstraction
Readability
Redundency-free design
Decomposition
Verbalization
Modularization
Information Hiding
Context-free modules
Loose coupling
Strong cohesion
Acyclic dependencies
|
|
ang2 |
Angular 2 Fundamentals |
21 hours |
Angular 2 is a new development platform for building mobile and desktop web applications.
Introduction to Angular 2
Bootstrap Angular 2 app
Components in Angular 2
Angular CLI
Introduction to TypeScript
Types, Functions, Lambdas
Classes, Interfaces, Decorators, Modules
Component Based Development
Develop custom components
Component Tree
Advanced Components
Directives and Pipes
Attributes directives and Structural directives
Pipes
Building blocks
Immutable.js
Observables
Dependency Injection
Forms
Template Driven Forms
Form Builder
REST and State Management
HTTP API
RxJS
Redux and Ngrx
Routing
Routes in Angular 2
Migrating from Angular 1.x to Angular 2
Migration Steps
Choosing a path
ng-forward and ng-upgrade
Unit Testing
Testing Components
Testing Services
|
|
ThinkPHP |
Getting started with ThinkPHP |
21 hours |
Audience
Developers
Format of the course
Heavy emphasis on hands-on practice. Most of the concepts are learned through samples, exercises and hands-on development.
ThinkPHP is a fast and simple PHP Object-Oriented MVC framework with support for UTF-8, plugins, role-based-control-access (RBCA), a template control engine and multi-databases.
Introduction to ThinkPHP
Object-oriention in ThinkPHP
Installing ThinkPHP
Model-View-Control in ThinkPHP
ThinkPHP Controller
ThinkPHP Model
ThinkPHP View
Working with templates
Authentication and role-based-access
Database access in ThinkPHP
Plugins in ThinkPHP |
|
reactnative |
React Native: Rapidly develop native iOS and Android apps with Javascript |
21 hours |
React Native is an open-source, cross-platform development framework for building mobile apps. It was developed by Facebook and enables developers to create a native look-and-feel experience for their apps on both Android and iOS. Unlike other cross-platform mobile development tools such as PhoneGap, React Native generates fully-native application UIs. No HTML5 UIs.
React Native provides a consistent developer experience based on JavaScript and the React (aka React.js or ReactJS) library and realizes true rapid mobile development by focusing on developer efficiency across all platforms -- learn once, write anywhere.
In this course, participants learn the principles and approach behind React Native as they take on the development of their own mobile application for Android and iOS.
Audience
Mobile application developers
Format of the course
Overview of React Native features and capabilities along with step-by-step development of a mobile application.
Introduction to React Native
React Native vs React
React Native vs PhoneGap, Titanium, etc.
React Native developer tools
Setting up DevTools
Building your first application
Working with Components
Working with Styles
Using platform APIs
Fetch API and networking
Using Redux for state management
Working with Modules
Architecting for multiple platforms
Testing your application
Debugging your application
Optimizing the performance of your application
Deploying your application to the iOS App Store
Deploying your Android application |
|
springcloud |
Spring Cloud: Building microservices with Spring Cloud |
14 hours |
Spring Cloud builds on Spring Boot to enable the development of distributed systems and microservices.
In this training we start with a discussion of microservice architecture. Participant knowledge is put to the test through exercises and the step-by-step development of sample microservices. By the end of this training participants will have a solid understanding of how to use Spring Cloud and related Spring technologies to rapidly develop cloud-scale, cloud-ready microservices.
Audience
Java developers wishing to rapidly build and deploy microservices
Format of the course
Heavy emphasis on hands-on practice. Most of the concepts are learned through samples, exercises and hands-on development.
Introduction
Microservice architecture, PaaS, and cloud-native design
Overview of Spring Cloud sub-projects
Config Server & Bus, Eureka, Ribbon, Feign, and Hystrix
Overview of Spring Boot
Setting up your development environment
Creating a Spring Boot application
Centralized, versioned configuration management with Spring Cloud Config
Dynamic configuration updates with Spring Cloud Bus
Service discovery with Eureka
Load balancing with Ribbon
Applying circuit breakers with Hystrix
Declarative REST clients with Feign
Working with API Gateway
Securing your microservices
Tracing microservices to uncover latencies
Troubleshooting
Closing remarks |
|
ccsint |
Introduction to CSS |
7 hours |
Introduction to CSS, for web page developers, designers, web producers.
CSS Basic
CSS Introduction
CSS Syntax
CSS Background
CSS Text
CSS Font
CSS Box Model
CSS Border
CSS Outline
CSS Margin
CSS Padding
CSS List
CSS Table
CSS Advanced
CSS Dimension
CSS Classification
CSS Positioning
CSS Pseudo-class
CSS Pseudo-element
CSS Image Gallery
CSS Image Opacity
CSS Media Types
CSS Don't
CSS Summary
|
|
drupalseo |
Drupal SEO |
14 hours |
With this course you can gain the knowledge you need to get your website to the top of search engines and to reach paying customers for your business with Drupal.
Seo basics
Business Analysis & Research
Keywords
Target Group
Website Structure
HTML basics
Tags used for SEO
Links
Drupal SEO Basics
Categorization
Clean Urls & Paths
Avoiding Duplicate Content
Correct Page Titles
Better 404 pages
Meta Tags
Link Attributes
XML, Page & Google News Sitemaps
Site Verification
Service Links
User Statistics
RSS Feeds
Drupal SEO Advanced
Advanced Automated & Semi-Automated Crosslinks
Related Content
Semantic Content (automatically create rich semantic metadata for your content)
Other
Webmaster Central
Google Adwords, Trends, Insights
SEO Tools
|
|
iosprog |
iOS Programming (iPhone/iPad) for Programmers |
35 hours |
All the skills and knowledge you need to make your first iPhone/iPad application using the latest iOS SDK and tools.
The environment
The iPhone Developer program and the tools (SDK, Xcode, IB, the iPhone/iPad simulator)
The language
Essential Objective-C
Using existing Cocoa classes and writing your own
The essential patterns
Performance and debugging
Memory management
Performance improvements
Debugging and troubleshooting
Multitasking
Multithreading essential
The User Experience
The application templates
The UI Controls
Creating different multi-view applications
The different gestures
UX rules and guidelines
Data management
Saving state
SQLite
XML
Core Data
Settings
Multimedia control and some special features
The camera API
The image picker
Playing and recording video
Playing and recording audio
The accelerometer
The proximity sensor
Notifications and the Event Kit
Quick intro on how to make 2D and 3D animations
Making location aware applications
Using core location
Targets and application types
iPhone vs iPad development
Universal applications
Intro to Web applications with HTML5 and CSS3
Interacting with a service
Hybrid applications
Delivering it to the public
Understanding iAd
Releasing to the App Store - The short path
|
|
corenet2dev |
Core Foundations of .NET 2.0 Development |
21 hours |
Objectives
After completing this course, students will gain the skills to:
Develop applications that use system types and collections.
Implement service processes, threading, and application domains in a .NET Framework application.
Embed configuration, diagnostic, management, and installation features into a .NET Framework application.
Implement serialization and input/output functionality in a .NET Framework application.
Audience
The audience for this course consists of Application Developers with the skills to develop business applications by using Visual Studio 2005 with either Visual Basic .NET or Visual C#.
Implementing System Types and Interfaces
Examining Primary System Types
Working with Special System Types
Working with Interfaces
Implementing Collections and Generics
Examining Collections and Collection Interfaces
Working with Primary Collection Types
Working with Generic Collections
Working with Specialized Collections
Working with Collection Base Classes
Configuring and Installing Assemblies
Working with an Assembly
Sharing an Assembly by Using the Global Assembly Cache
Installing an Assembly by Using Installation Types
Configuring an Assembly by Using Configuration Type
Performing Installation Tasks
Monitoring and Debugging Applications
Working with Application Processes
Managing Application Performance
Debugging Applications
Tracing Applications
Embedding Management Information and Events
Reading and Writing Files
Managing the File System
Working with Byte Streams
Compressing and Protecting Stream Information
Managing Application Data
Manipulating Strings Efficiently
Working with Regular Expressions
Serializing Data
Generating Serialized Binary and Soap Formats
Generating Serialized XML Formats
Creating Custom Serialization Classes
Implementing Delegates and Events
Controlling Interaction Between Components by Using Delegates
Controlling Interaction Between Components by Using Events
|
|
2870 |
Programming using ASP.NET MVC 4 |
21 hours |
Objectives
MVC Web applications offer a clean separation of concerns between the business-logic classes, Web pages, and the controller. Microsoft ASP.NET MVC 4 offers Web developers all the benefits of MVC allied with all the power of the .NET platform. This course provides full coverage of ASP.NET MVC 4, including Test Driven Development and JQuery.
After completing this course, delegates will be able to
Understand the Role of the Model, View, and Controller Design Pattern
Create Industrial-Strength Applications
Apply Test Driven Development Methods
Implementing Navigation Between Pages
Implement Rich User Interfaces with JQuery and Ajax
Audience
ASP.NET developers who want to use the MVC architecture.
Module 1: Getting Started with ASP.NET MVC
ASP.NET MVC project templates
Understanding the structure of an ASP.NET MVC project
Naming conventions
Creating views
Defining controllers
Defining a data model
Module 2: Creating a Complete ASP.NET MVC Application
Creating strongly-typed views
Understanding URLs and action methods
Using HTML helpers
Handling form post-backs
Data validation
Module 3: Using the Razor View Engine
Razor design goals
Implementing a Razor view
Razor syntax
Accessing model data in Razor views
Module 4: Industrial-Strength ASP.NET MVC Applications
ASP.NET application architecture best practices
Implementing a repository and Entity Framework data model
Using Dependency Injection
Implementing a custom controller factory
Module 5: Test Driven Development with ASP.NET MVC
Recap of TDD
Unit Testing frameworks
Walk-through of using TDD with ASP.NET MVC
Module 6: View Techniques
Defining and using custom HTML helpers
Defining a layout/master page
Using styles
Defining and using partial views
Razor helper method syntax
Module 7: Implementing Navigation
Defining view-model classes
Implementing data filtering in a controller
Understanding the routing mechanism
Adding custom entries to a route table
Defining defaults, parameters, and validation
Generating URLs and hyperlinks
Custom route constraints
Module 8: State Management
Using hidden fields
Session and application state
Custom model bindings
Module 9: Additional Techniques
View scaffold templates
Controller scaffold templates
Global filters
Model binding
Asynchronous controllers
Authentication options, including enabling logins from Facebook etc.
Module 10: Using Ajax and jQuery with ASP.NET MVC
Overview of Ajax and ASP.NET MVC
Unobtrusive Ajax
Using Ajax action links
Overview of jQuery
jQuery techniques
Using jQuery UI
|
|
3164 |
Visual Basic for Applications (VBA) for Analysts |
21 hours |
The course is designed for users of Excel for creating analyzes and reports.
Macros
Recording and editing macros
Where to store macros.
Assigning macros to forms, toolbars, keyboard shortcuts
VBA Environment
Visual Basic Editor and its options
Keyboard Shortcuts
Optimizing the environment
Introduction to procedural programming
Procedures: Function, Sub
The data types
The conditional statement If...Then....Elseif....Else....End If
Instruction Case
Loop while, until
Loop for ... next
Instructions break the loop(exit)
Strings
Combining strings (concatenation)
Conversion to other types - implicit and explicit
Features processing strings
Visual Basic
Download and upload data to a spreadsheet (Cells, Range)
Download and upload data to the user (InputBox, MsgBox)
The declaration of variables
The extent and lifetime of variables
Operators and their priorities
Options modules
Create your own functions and use them in a sheet
Objects, classes, methods and properties
Securing code
Security code tampering and preview
Debugging
Processing step
Locals window
Immediate window
Traps - Watches
Call Stack
Error handling
Types of errors and ways to avoid
Capturing and handling run-time errors
Structures: On Error Resume Next, On Error GoTo label, On Error GoTo 0
Excel Object Model
The Application object
Workbook object and a collection of Workbooks
Worksheet Object and Collection Worksheets
Objects ThisWorkbook, ActiveWorkbook, ActiveCell ....
Object Selection
Collection Range
Object Cells
Display data on the statusbar
Optimization using ScreenUpdating
The time measurement by the method Timer
The use of external data sources
Using ADO library
References to external data sources
ADO objects:
Connection
Command
Recordset
Connection string
Create connections to different databases: Microsoft Access, Oracle, MySQL
Reporting
Introduction to the SQL language
The basic structure of SQL (SELECT, UPDATE, INSERT INTO, DELETE)
Calling a Microsoft Access query from Excel
Forms to support the use of databases
|
|
mlfunpython |
Machine Learning Fundamentals with Python |
14 hours |
The aim of this course is to provide a basic proficiency in applying Machine Learning methods in practice. Through the use of the Python programming language and its various libraries, and based on a multitude of practical examples this course teaches how to use the most important building blocks of Machine Learning, how to make data modeling decisions, interpret the outputs of the algorithms and validate the results.
Our goal is to give you the skills to understand and use the most fundamental tools from the Machine Learning toolbox confidently and avoid the common pitfalls of Data Sciences applications.
Introduction to Applied Machine Learning
Statistical learning vs. Machine learning
Iteration and evaluation
Bias-Variance trade-off
Machine Learning with Python
Choice of libraries
Add-on tools
Regression
Linear regression
Generalizations and Nonlinearity
Exercises
Classification
Bayesian refresher
Naive Bayes
Logistic regression
K-Nearest neighbors
Exercises
Cross-validation and Resampling
Cross-validation approaches
Bootstrap
Exercises
Unsupervised Learning
K-means clustering
Examples
Challenges of unsupervised learning and beyond K-means
|
|
elkdd |
Embedded Linux Kernel and Driver Development |
14 hours |
A two day course around 60% hands-on labs focusing on Embedded linux kernel internals and development and investigating how to write several types of device drivers
What is the Linux kernel?
Getting Kernel source code
Configuring, compiling and booting the kernel
Linux kernel modules
Character device drivers
Using Git for sourcce code management
|
|
symfony3webdev |
Web Development with Symfony3 |
28 hours |
Object Oriented Programming
Classes and objects
Properties and methods
Constructor and destructor methods
Class inheritance
Attributes and methods scopes (visibility)
Error handling with exceptions
Namespaces
Introducing the Symfony famework
Introducing the Symfony framework and its ecosystem
Installing the Symfony « Standard Edition Distribution »
Discovering the Symfony project architecture (application, bundles, libraries, bundles etc.)
Understanding the HTTP request processing workflow
Understanding the concept of environment (development, production and testing)
Introducing the coding and files naming conventions
Discovering the concept of a « Bundle »
Debugging the Code
Getting help from the « Web Debug Toolbar »
Introspecting the recorded logs
Profiling HTTP requests thanks to the « Web Profiler » application
Spotting problems thanks to explicit errors and exceptions stack traces
Using the Debug and VarDumper components features
Configuring the application
Comparing the supported built-in configuration format: XML, YAML and PHP
Configuring the application thanks to global parameters
Configuration application’s routes and URLs with annotations
Overriding the configuration defined by a built-in or third-party « bundle »
Generating Contents for the End User
Introducing the Twig templates engine
Comparing Twig and raw PHP templating strategies
Accessing global variables from Twig templates (request, session, user)
Using tags, filters and function to generate and format contents in a Twig template
Making templates truly extensible thanks to the template inheritance feature
Splitting templates into smaller templates chunks to avoid code duplications
Rendering a Symfony controller from within a Twig template
Generating URLs based on the application’s routes configuration
Rendering Symfony forms with custom Twig view helpers
Developping Controller and Analyzing the Request
Designing a controller class with its action methods
Mapping URL patterns to Symfony controllers thanks to annotations
Generating raw responses and Twig templates based responses
Accessing client’s information from the Request object
Reading and writing session data
Reading and writing cookies data
Triggering a 404 error page when the resource is not found
Triggering an internal redirect to another controller to avoid code duplications
Redirecting the user to another page
Interacting with the End User thanks to Forms
Discovering the « Form » component
Designing and processing simple web forms
Adding validation constraints on submitted form fields’ data
Prototyping the form rendering thanks to Twig view helpers
Gathering the form submitted data and processing them
Sending the form validated and filtered data by e-mail to some recipient
Internationalizing and Localizing the User Interface
Discovering the « Translation » component
Changing the default user’s locale
Defining custom abstract translation keys in Twig templates
Dealing with dynamic translations including pluralized sentences
Dependency Injection and Service Container
Understanding the dependency injection principle
Getting started with the Symfony service container
Listing all built-in Symfony services thanks to the command line tools
Registering new custom business services in the dependency injection container
Accessing a registered service from the service container
Creating and accessing global configuration parameters from the container
Contracting a Quality Insurance with Automated Tests
Discovering the PHPUnit tests automation framework
Understanding the goals of automating tests (unit and functional tests)
Configuring an automated tests suite
Designing and executing a unit tests suite
Designing and executing a functional tests suite
Generating code coverage reports
Interacting with the End User and Forms
Designing and processing web forms
Automating form rendering with Twig view helpers
Customizing form rendering with built-in and custom Twig form themes
Configuring form field types as services
Applying built-in validation constraint rules on submitted data
Applying custom validation constraint rules on submitted data
Contextualizing the data validation thanks to validation groups
Restricting Access to Secured Areas of the Application
Getting started with authentication and authorization principles
Securing some application’s pages thanks to a form based authentication strategy
Implementing the Security Guard sub component to handle authentication
Setting up an access control policy based on user’s roles
Testing user’s permissions from a controller and a Twig template
Registering custom authorization rules thanks to the security « voters »
Improving Application Performances with HTTP Caching and ESI
Getting started with the HTTP caching workflows
Discovering the different kind of cache systems
Comparing the expiration and validation cache strategies
Applying expiration and validation cache constraints to generated web pages
Caching page fragments thanks to the ESI technology (« Edge Side Includes »)
Installing and configuring the Symfony’s built-in reverse-proxy cache
Querying a Relational Database System with Doctrine
Discovering the basics of the Doctrine ORM
Understanding the concepts of « entities » and « repositories »
Automating PHP classes and SQL queries code generation with Doctrine
Persisting data to the database thanks to the Doctrine ORM entity manager
Fetching data back from the database thanks to Doctrine
Building and executing custom SQL queries thanks to the Doctrine Query Builder object
|
|
react |
React: Build highly-interactive web applications |
21 hours |
React is an open source Javascript library that can be used to create interactive web and mobile applications. It is often compared to MVC frameworks such as Angular, Ember and Backbone, however, React is distinct in its focus on the UI of the application (the View in MVC). Its unique approach to rendering highly interactive UIs is both powerful and liberating and has led to React's popularity.
In this training we demonstrate React's power and flexibility, compare it to alternative frameworks, and walk participants step-by-step through the creation of their own application.
By the end of this course, participants will have a solid understanding of React's design philosophy and be in a position to decide when and where it makes sense to use React and when to rethink the conventional MVC model. With an emphasis on hands-on practice and the completion of a real application, this training will be invaluable to web application developers wishing to use React to boost their productivity and value.
Audience
Front-end developers
Web developers
Javascript programmers
Format of the course
Overview of React's features and capabilities along with step-by-step development of a web application.
Introduction
Design principles behind React
Setting up your development environment
How components work in React
The component life cycle
Building your first component
Handling state in React
Defining your components' parent/child relationships
Event handling and conditional rendering
Container vs Presentational Components
Testing your React web application
Integrating React with other frameworks and plugins
Bringing it all together -- your own app
Closing remarks
|
|
xamarin |
Xamarin: Build native mobile applications for Android, iOS and Windows from a single code base |
14 hours |
Xamarin is an open-source, C# based set of tools for writing Android, iOS and Windows apps with native user interfaces and a shared code base across all platforms. It allows developers to use the same IDE, language, and APIs everywhere -- anything that can be done in Objective-C, Swift, or Java can be done in C# with Xamarin. Xamarin was bought by Microsoft in 2016 and is included with Visual Studio.
In this training, participants learn key aspects of Xamarin as they take on the development of their own set of mobile applications for Android, iOS and Windows.
Audience
Mobile developers and programmers
Format of the course
Overview of Xamarin's features and capabilities along with step-by-step development of a mobile application (for iOS, Android and Windows).
Introduction
Understanding the Xamarin architecture
Xamarin developer tools
Setting up your development environment
Creating your first application
Making your application interactive
Model Classes and Event Handling
Creating the UI
Collections, Persistence, and MVVM (Model-View-View-Model) in Xamarin
Data binding in Xamarin
Using pages in Xamarin
Architecting for multiple platforms
Building your application
Testing your application
Debugging your application
Optimizing the performance of your application
Deploying your application to the iOS App Store
Deploying your Android application |
|
qtprogramming |
QT Programming |
21 hours |
Qt is an application framework for developing cross-platform application software.
This training provides in-depth coverage of Qt and its modules. By the end of this training, participants will have the necessary knowledge and practice to develop their own application using QT.
Audience
Software developers
Format of the course
An instructor-led course with theoretical coverage of QT together with exercises and a large component of hands-on development.
Introduction to Qt
Objects and Core Types
Core Classes
Objects
Object Communication
Widgets and Designer
Widgets
Dialogs
Applications and Painting
Painting and Styling
Application Creation
Models and Views
Graphics View
Qt Additional Models
Multithreaded Programming and Multimedia
Multimedia Programming
Inter-Process Communication
Miscellaneous Topics
Extending Qt with Plugins
Data Processing
XML Patterns
Animation
Closing remarks
|
|
haskellfun |
Haskell Fundamentals |
14 hours |
This course covers the basics of Haskell programming language.
The course introduces the ideas of Functional Programming and teaches the essential concepts of it, and by this introduces the student to the Haskell programming language. The course explores the fundamental differences with imperative programming and teaches the skill of thinking functionally.
Students should expect to learn all the necessary tools and concepts to start writing and understanding simple Haskell programs.
Introduction to Haskell
Platform and tools
Hello World program
A bit of history
Haskell syntax
Functions
Case distinction and pattern matching
Layout (indentation)
Control structures (if, case, let, where)
Type system
Basic types
Simple function types
Polymorphism
Higher order functions
Custom types
Numbers in Haskell
Type classes
Building programs
IO handling
Module system
Packages and libraries
Compiling applications
Examples and case studies
Eight queens puzzle in Haskell
Dynamic programming and memoization in Haskell
Simplified parsing of CSV files
An HTTP client
|
|
haskelladv |
Advanced Haskell |
14 hours |
This course is for those users of Haskell who have a good grasp of the basics and want a deeper understanding of the language and be able to tackle serious, larger-scope problems in Haskell.
Participants should expect to get a working understanding of the most important features of modern Haskell; be able to read and write advanced Haskell programs and libraries.
Basic Typeclassopedia
Functor
Applicative
Foldable, Traversable
Monads
Other (Arrow, etc.)
Advanced types
Algebraic data types in depth
Advanced Type classes
Type families
GADTs
Debugging and code optimizing
Strictness in data types and functions
Memory and CPU profiling
Efficient data structures (bytestring, text, vector and co.)
Note on "unsafes"
Understanding the Runtime System
Memory layout in GHC
Unpacking strict fields
Understanding and reading Core
Concurrency in Haskell
Haskell threads
MVars and co.
STM
Parallelism
Foreign Function Interface
FFI basics
Safe vs. unsafe
Globals in Haskell
Template Haskell
Splicing and quotation
The Q monad
Reification
|
