|
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
|
|
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 |
|
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 |
|
behave |
Behave: BDD with Python (Cucumber/Gherkin for Python) |
7 hours |
Behave is an open-source, Python-based BDD framework for writing tests in a natural language style.
BDD, or Behavior Driven Development, is an agile software development technique that encourages collaboration among developers, QA and non-technical business people in a software project.
This training begins with a discussion of BDD and how the Behave framework can be used to carry out BDD testing for web applications. Participants are given ample opportunity to interact with the instructor and peers while implementing the concepts and tactics learned in this hands-on, practice-based lab environment.
By the end of this training, participants will have a firm understanding of BDD and Behave, as well as the necessary practice to implement these techniques and tools in real-world test scenarios.
Audience
Testers and 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
Business Driven Development (BDD) and Acceptance Test Driven Development (ATDD)
BDD as a collaboration tool for software engineers, test engineers and business people
Defining your project requirements
Setting up your environment for web application testing
Gherkin: writing your stories in a user-friendly language
The anatomy of the Feature file
Writing your first feature
Writing scenarios for your feature
Writing step definitions
Passing parameters to Steps
Creating scenario outlines to pass multiple arguments
Sharing data between steps
Organizing features and scenarios with tags
Setup and teardown
Closing remarks |
|
drupal7adm1 |
Administering a Drupal 7 Website |
7 hours |
This course is for people who are completely new to Drupal 7. It will lead you through the basics of running a simple community website with Drupal, where things are and what to expect.
An Introduction to Drupal 7
What is Drupal?
The building blocks
Where things live
Managing Users
User settings
Creating, deleting and editing users
Roles and access
Managing Content
Creating and editing content types
Workflow options
Creating, editing and deleting content
Searching content
Using blocks
Ordering Content
Drupal taxonomy overview
Creating a directory
Free tagging
The Drupal menu system
Friendly URLs and managing URL aliases
Troubleshooting
Reading the logs
Watchdog
Going offline for maintenance
Paths and Redirections
Creating path aliases (manually and automatically)
Paths and SEO
Redirections
Changing URL and redirecting users to new one path
|
|
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 |
|
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 |
|
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
|
|
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 |
|
reactvr |
React VR: Creating Virtual Reality apps with Javascript |
7 hours |
React VR is a framework that lets you build VR apps using only JavaScript. It combines modern APIs like WebGL and WebVR with the declarative power of React, producing 360 experiences that can be consumed through a web browser on a variety of devices.
In this instructor-led training, participants will have extensive opportunity for hands-on practice in developing VR applications. Through interactive discussions and project-based exercises, participants will steadily build their sample VR apps. By the end of this course, participants will have gained the knowledge and practice to build their own production version of a VR app to publish online.
Audience
Web developers
Game developers
Hobbyists looking to develop their first VR app
Format of the course
Part lecture, part discussion, heavy hands-on practice
Introduction
Overview of React VR concepts
Installing Node.js
Creating your first project
Configuring your project
Controlling component through props and state
Setting the layout and style in your app
3D Coordinates and Transforms
Handling input events
Rendering fonts and text in VR
Viewing your project on a mobile phone
Dealing with local storage
Grabbing information from the web to use in your VR application
Other React VR components
Using other APIs available in React VR
Publishing Your Project
Closing remarks |
|
2794 |
HTTP Web Server (Nginx, Apache, JBoss) |
28 hours |
Section 1: Nginx (Day 1 duration 1.5 Days)
Module 1: Installing Nginx and Third-Party Modules
Installing Nginx using a package manager
Configuring for web
Configure the options to specify paths
Table: HTTP configure options
Enabling various modules
Table: HTTP module configure options
Disabling unused modules
Table: Disable configure options
Installing third-party modules
Module 2: A Configuration Guide
The basic configuration format
Nginx global configuration parameters
Table: Global configuration directives
Using include files
The HTTP server section Client directives, File I/O directives, Hash directives, Socket directives
The virtual server section
Configuring Locations – where, when, and how
Module 3: Nginx as a Reverse Proxy
The proxy module
Proxy module directives
The upstream module: Keepalive connections and Load-balancing algorithms
Types of upstream servers: Single upstream server, Multiple upstream servers, Non-HTTP upstream servers
How to handle upstream problems
Module 4: Reverse Proxy Advanced Topics
Introduction to Security
Encrypting traffic with SSL
Authenticating clients using SSL
Blocking traffic based on originating IP address
Isolating application components for scalability
Reverse proxy performance tuning: Buffering, Caching, Compressing
Module 5. The Nginx HTTP Server
HTTP server directives
HTTP logging directives
HTTP file-path directives
Name resolution directives
HTTP client interaction directives
HTTP limits directives
HTTP access module directives
HTTP streaming directives
Module 6. Nginx Load Balancing
About Load Balancing
Setting up the environment
Using the Upstream Module
Using the right directives (Weight, Hash, Max Fails, etc.)
Testing your configuration
Module 7: Troubleshooting Techniques
Analyzing log files
Configuring advanced logging
Common configuration errors
Performance problems
Using the Stub Status module
Section 2: Apache (Day 2 duration 1 day)
Module 1. Installation
Installing Apache
Apache starting, stopping and Apache restarting
Apache uninstalling
Finding Apache’s files location
Module 2. Adding Common Modules
Installing a Generic installation modules
Installing Unix mod_dav
Installing mod_perl
Installing Unix mod_php
Installing mod_ssl SSL (Secure Socket Layers)
Finding Modules Using modules.apache.org
Installing mod_security
Module 3. Logging
Getting more logs entries and Details
Logs rotating
Module 4. Virtual Hosts
Setting Up Name-Based Virtual Hosts
Setting Up address-based virtual hosts
Module 5. Aliases, Redirecting, and Rewriting
Mapping a URL to a Directory
Creating a New URL for Existing Content
Giving URLs (Uniform Resource Locators) users having own URLs Users Their Own URLs
Redirecting to another location
Redirecting Several URLs to the same Destination
Rewriting elements between path and query string
Turning URL Segments into query arguments
Module 6. SSL
Installing SSL
Generating self-signed SSL certificates
Generating a trusted CA
Serving a portion of site via SSL
Authenticating with Client certificates
Module 7. Dynamic Content
Enabling a CGI Directory
Enabling CGI Scripts in Non-ScriptAliased Directories
Specifying a Default Document in a CGI Directory
Enabling and using WebDAV
Complex Configurations and the security Issues with WebDAV
Section 3: Java Virtual Machine (Day 3 duration 0.5 days)
Tuning the Java Virtual Machine
Choosing the JVM settings
Sizing the garbage collector generations
Where to configure JVM settings
When you cannot allocate enough memory for the JVM
The correct amount of memory to grant your application
Setting the correct heap size
The correct ratio between the young and old generations
The garbage collector algorithms
Choosing the right garbage collector for your application
The G1 garbage collector
Debugging garbage collection
Making good use of the memory
Handling 'Out of Memory' errors
Finding the memory leak in your code
Section 4: Java Web
Introduction to Java Web technologies
What is a Servlet and when to use
Introduction to JSP
Servlet versus JSP
What is a JavaBean
Introduction to JEE
The role of EJB (Session Beans, Entity Beans, MDB Beans) in an enterprise application
The MVC pattern
- The role of the Model
- The role of the View
- The role of the Controller
Section 5: Multimedia content and HTML 5
HTML 5 Audio and Video elements
Different streaming protocols
- Internet Protocol television (IPTV)
- HTTP Live Streaming
Server implementations
The role of OTT streaming
Section 6: JBoss (Day 4 duration 1 day)
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
Module 7. JBoss Drools - Introduction
Getting the software
Installing the BRMS/Guvnor
Installing the Drools plug-in
Module 8. Using the Guvnor
General Navigation
Administration (Rules, Packages, Deployment)
Building a Guided Rules with the Guvnor
From Guvnor to JBoss IDE
Testing your Rules
|
|
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
|
|
webpack |
Webpack: A modular approach to web application development |
7 hours |
Webpack is a JavaScript module bundler that enables developers to apply a modular approach to building large, single-page web applications. A powerful and important modern front-end development tool, Webpack is the go-to solution for getting all of your CSS and JavaScript files to act as one. Webpack plays well with front-end workflows such as Babel, ReactJS, and CommonJS.
In this training, participants will learn how to transform, bundle, and process JavaScript modules and other web assets with Webpack. The principles of modular web application development and its practical implementation are learned through discussion and live, hands-on practice.
By the end of the training, participants will have a thorough understanding of Webpack's features and capabilities, as well as the practice needed to implement Webpack into their own front-end development workflow.
Audience
Front-end developers
Web developers
Javascript programmers
Format of the course
Part lecture, part discussion, heavy hands-on practice
Introduction
Why Webpack?
The modern front-end workflow
Installing Webpack
Running a basic Webpack build
Defining the webpack.config file
Expanding the config file
Working with Webpack loaders, preloaders and plugins
Creating a start script
Implementing React with Webpack
Processing CSS, HTML and images with Webpack
Loading CSS
Transpiling Sass
Loading images
Processing HTML
Code splitting with Webpack
Setting up a Webpack server
Closing remarks |
|
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
|
|
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
|
|
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
|
|
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 |
|
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 |
|
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
|
|
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
|
|
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
|
|
DrupalRespDesign |
Drupal Responsive Design |
7 hours |
Explains how to create responsive and adaptive design using Drupal. Usually we use most stable version of Drupal and Drupal modules.
This course tries to use Drupal modules to limit the amount of CSS or Javascript code which need to be to be written.
Responsive Design Pricinples
Adaptive Design Principles
Understanding breakpoints
Overview of existing Drupal themes
Making menus responsive and adaptive
Scaling Images
Making Views responsive
Making Panel responsive
Responsive Drupal Forms
|
|
cucumber |
Cucumber: Implementing Behavior Driven Development (BDD) with Cucumber |
14 hours |
Behaviour-Driven Development (BDD) is an Agile methodolgy aimed at improving the communication and collaboration among Software Developers, Quality Assurance / Testers, Business Analysts, and other parties involved in a project.
Cucumber is an open-source “story-based” framework written in Ruby. It enables Behavior Driven Development (BDD) by allowing for the creation of tests that are understandable by technical as well as non-technical people such as business stakeholders.
This course walks participants through real-life cases for Behavior Driven Development (BDD) and demonstrates hands-on how to implement Cucumber in various test scenarios.
Audience
Testers and Developers
Format of the course
The course includes a discussion of Behavior Driven Development (BDD) and how Cucumber can be used to carry out BDD testing in various contexts such as web application testing. Participants will be walked through the writing of their own user stories, test cases and executable test code.
Introduction
Installing and configuring Cucumber
Business Driven Development (BDD) and Acceptance test–driven development (ATDD)
Involving the business analysts in your organization
Defining your project requirements
The testing ecosystem (IDEs, programming languages, testing frameworks and build libraries)
Setting up a web application testing system
Gherkin: writing your stories in a user-friendly language
Writing features
Writing scenarios
Writing step definitions
Organizing features and scenarios with tagging
Working with hooks
Working with databases
An overview of the Ruby ecosystem
Web-based test automation with Capybara
Refactoring Cucumber
Using Cucumber with Selenium
Generating reports
Emerging trends
Conclusion |
|
sass01 |
Syntactically Awesome StyleSheets - Sass |
14 hours |
Very Short Intro
CSS limitations
Less vs Sass
Community and improvment
CSS Extensions
Nested Rules
Referencing Parent Selectors: &
Nested Properties
Placeholder Selectors: %foo
SassScript
Interactive Shell
Variables: $
Data Types
Operations
Parentheses
Functions
Interpolation: #{}
& in SassScript
Variable Defaults: !default
@-Rules and Directives
@import
@media
@extend
@at-root
@debug
@warn
@error
Control Directives & Expressions
if()
@if
@for
@each
@while
Mixin Directives
Defining a Mixin: @mixin
Including a Mixin: @include
Arguments
Passing Content Blocks to a Mixin
Function Directives
Output Style
:nested
:expanded
:compact
:compressed
Extending Sass
Defining Custom Sass Functions
Cache Stores
Custom Importers
|
|
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 |
|
WordPress |
WordPress |
21 hours |
Audience: This course is general and can be attended by anyone.
Most precisely, this course is attended by people who are interested in developing a website without any coding /programming skills.Installing WordPress
Hosting options
Sandbox Server
Setting Your Directory Permissions
Getting Around WordPress
Dashboard
Posts, Pages, Tags, Media, and More: Content Administration
Tapping into the Core Settings for Your Blog
Other Settings
Configuring WordPress
Choosing the Right Settings for Your Blog
Moderating Comments and Comment Spam
Managing Additional Authors on Your Blog
Caching and Other Tune-Ups
WordPress.com Notes
How WordPress.com Is Different Than WordPress.org
WordPress.com and WordPress.org: Complementary Differences
Creating Your Account
Setting Up Different Blogs
Becoming Familiar with the WordPress.com Dashboard
Getting Your Settings Right for WordPress.com
Picking the Right Theme for Your Blog
Configuring Sidebar Widgets on Your Blog
When to Add WordPress.com Upgrades to Your Blog
Organizing the Content on Your Blog
Understanding Posts Versus Pages
Organize Your Posts with Categories
Connect Your Posts Together with Tags
Custom Post Types and Custom Taxonomies
Adding a Blogroll of Links to Your Blog
Creating and Managing Content with WordPress
Hands On with the Editors
Hands on with the New Image Editor in Detail
Adding Media to Your Blog and Posts
Plugins
Finding and Using Plugins
Finding Plugins
Installing Plugins Quickly and Easily
Upgrading Plugins
Recommended Plugins
Themes
Understanding the Structure of WordPress Themes
Finding Themes and Choosing the Right One for Your Blog
Installing Themes on Your Blog
Configuring Extra Features on Themes
Configuring Widgets
Editing a Themes to Make it Your Own
Using Theme Frameworks and Parent-Child Themes
Theme Best Practices
WordPress.com Notes
Maintaining WordPress
Updating and Upgrading WordPress
Updating Plugins and Themes
Database Maintenance for WordPress Users
WP-DBManager
|
|
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. Developed by Facebook, it 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 enables 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 |
|
django |
Web Development with Django |
21 hours |
Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design.
Audience
This course is directed at developers and engineers seeking to incorporate Django in their projects
Getting Started
Installation
Intro to Django
Object-relational mapper
URLs and views
Templates
Forms
Developmental process
Authentication
Admin
Internationalization
Security
Tutorial
Requests and responses
Models and the admin site
Views and templates
Forms and generic views
Testing
Static files
Customizing the admin site
Advanced Tutorials
How to write reusable apps
Writing your first patch for Django
|
|
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 |
|
btstrp |
Bootstrap for Web Developers |
14 hours |
Bootstrap is the most popular HTML, CSS, and JS framework for developing responsive, mobile first projects on the web.
Audience
This course is directed at web developers seeking to utilize Bootstrap in their projects.
Getting Started
Precompiled
Source Code
Compiling CSS and Javascript
Installing Grunt
Available Grunt commands
Troubleshooting
Basic template and Components
Basic Template
Bootstrap Theme
Grids
Jumbotron
Narrow Jumbotron
Navbars
Custom Components
Experiments
Tools
Bootlint
Disabling Responsiveness
Browser and Device support and compatibility
Accessibility
Components
Glyphicons
Dropdowns
Button groups
Button dropdowns
Input groups
Navs
Navbar
Breadcrumbs
Pagination
Labels
Badges
Jumbotron
Page header
Thumbnails
Alerts
Progress bars
Media object
List group
Panels
Responsive embed
Wells
CSS
Overview
Grid system
Typography
Code
Tables
Forms
Buttons
Images
Helper classes
Responsive utilities
Using Less
Using Sass
Javascript
Overview
Transitions
Modal
Dropdown
Scrollspy
Tab
Tooltip
Popover
Alert
Button
Collapse
Carousel
Affix
|
|
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 |
|
web2py |
Web Development with Web2Py |
28 hours |
web2py is a python based free open source full-stack framework for rapid development of fast, scalable, secure and portable database-driven web-based applications.
Audience
This course is directed at Engineers and Developers using web2py as a framework for web development
Getting Started
Setup web2py
Web2py
Overview
Startup
Simple Examples
Admin
App Admin
The core
Command Line Options
Workflow
Dispatching
Libraries
Applications
API
Accessing API from Python Modules
request
response
session
cache
URL
HTTP and Redirection
Internationalization
Application Init
URL rewrite
Running tasks in the background
web2py scheduler
Third party modules
Execution environment
Cooperation
Logging
WSGI
The views
Basic Syntax
HTML helpers
Built-in helpers
Custom Helpers
BEAUTIFY
Server-side DOM and parsing
Page Layout
Functions in views
Blocks in views
The database abstraction layer
Dependencies
The DAL: A quick tour
Using the DAL "stand-alone"
DAL constructor
Table constructor
Field Constructor
Migrations
Fixing broken migrations
Migration control summary
insert
commit and rollback
Raw SQL
drop
Indexes
Legacy databases and keyed tables
Distributed transaction
More on uploads
Query, Set, Rows
select
Other methods
Computed Fields
Virtual Fields
One to many relations
Many to Many
list: and contains
other operators
Generating raw sql
Exporting and importing data
Caching selects
Self-Reference and aliases
Advanced features
Gotchas
Forms and validators
FORM
SQLFORM
Other types of forms
CRUD
Custom Forms
Validators
Widgets
SQLFORM.grid and SQLFORM.smartgrid
grid and smartgrid access control
smartgrid plurals
Emails and SMS
Setting up email
Sending emails
Sending SMS messages
Using the template system to generate messages
Sending messages using a background task
Reading and managing email boxes (Experimental)
Access Control
Authentication
Authorization
Central Authentication Service
Services
Rendering a dictionary
Remote procedure calls
Low level API and other recipes
Restful web services
Services and Authentication
jQuery and Ajax
web2py_ajax.html
jQuery effects
The Ajax function
Components and Plugins
Components, LOAD and Ajax
Plugins
Deployement Recipes
Deployment: development and production
Deployment recipes: Infrastructure
Other Recipes
Upgrading
How to distribute your applications as binaries
Developing with IDEs: WingIDE, Rad2Py, Eclipse and PyCharm
SQLDesigner
Publishing a folder
Functional testing
Building a minimalist web2py
Fetching an external URL
Pretty dates
Geocoding
Pagination
httpserver.log and the Log File Format
Populating database with dummy data
Accepting credit card payments
Dropbox API
Streaming virtual files
|
|
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 |
|
owasp |
Web Security with the OWASP testing framework |
28 hours |
The Open Web Application Security Project is an online community which creates freely-available articles, methodologies, documentation, tools, and technologies in the field of web application security.
OWASP offers testing frameworks and tools for identifying vulnerabilities in web applications and services
Audience
This course is directed at Developers, Engineers and Architects seeking to secure their web apps and services
Web Security overview
Top 10 2013
Mobile Top 10 2016
2016 Top 10 Proactive Controls
OWASP Testing
Introduction
The OWASP Testing Project
Principles of Testing
Testing Techniques Explained
Deriving Security Test Requirements
Security Tests Integrated in Development and Testing Workflows
Security Test Data Analysis and Reporting
The OWASP Testing Framework
Overview
Phase 1: Before Development Begins
Phase 2: During Definition and Design
Phase 3: During Development
Phase 4: During Deployment
Phase 5: Maintenance and Operations
A Typical SDLC Testing Workflow
Web Application Security Testing
Introduction and Objectives
Testing Checklist
Information Gathering
Conduct Search Engine Discovery and Reconnaissance for Information Leakage (OTG-INFO-001)
Fingerprint Web Server (OTG-INFO-002)
Review Webserver Metafiles for Information Leakage (OTG-INFO-003)
Enumerate Applications on Webserver (OTG-INFO-004)
Review Webpage Comments and Metadata for Information Leakage (OTG-INFO-005)
Identify application entry points (OTG-INFO-006)
Map execution paths through application (OTG-INFO-007)
Fingerprint Web Application Framework (OTG-INFO-008)
Fingerprint Web Application (OTG-INFO-009)
Map Application Architecture (OTG-INFO-010)
Configuration and Deployment Management Testing
Test Network/Infrastructure Configuration (OTG-CONFIG-001)
Test Application Platform Configuration (OTG-CONFIG-002)
Test File Extensions Handling for Sensitive Information (OTG-CONFIG-003)
Review Old, Backup and Unreferenced Files for Sensitive Information (OTG-CONFIG-004)
Enumerate Infrastructure and Application Admin Interfaces (OTG-CONFIG-005)
Test HTTP Methods (OTG-CONFIG-006)
Test HTTP Strict Transport Security (OTG-CONFIG-007)
Test RIA cross domain policy (OTG-CONFIG-008)
Identity Management Testing
Test Role Definitions (OTG-IDENT-001)
Test User Registration Process (OTG-IDENT-002
Test Account Provisioning Process (OTG-IDENT-003)
Testing for Account Enumeration and Guessable User Account (OTG-IDENT-004)
Testing for Weak or unenforced username policy (OTG-IDENT-005)
Authentication Testing
Testing for Credentials Transported over an Encrypted Channel (OTG-AUTHN-001)
Testing for default credentials (OTG-AUTHN-002)
Testing for Weak lock out mechanism (OTG-AUTHN-003)
Testing for bypassing authentication schema (OTG-AUTHN-004)
Test remember password functionality (OTG-AUTHN-005)
Testing for Browser cache weakness (OTG-AUTHN-006)
Testing for Weak password policy (OTG-AUTHN-007)
Testing for Weak security question/answer (OTG-AUTHN-008)
Testing for weak password change or reset functionalities (OTG-AUTHN-009)
Testing for Weaker authentication in alternative channel (OTG-AUTHN-010)
Authorization Testing
Testing Directory traversal/file include (OTG-AUTHZ-001)
Testing for bypassing authorization schema (OTG-AUTHZ-002)
Testing for Privilege Escalation (OTG-AUTHZ-003)
Testing for Insecure Direct Object References (OTG-AUTHZ-004)
Session Management Testing
Testing for Bypassing Session Management Schema (OTG-SESS-001)
Testing for Cookies attributes (OTG-SESS-002)
Testing for Session Fixation (OTG-SESS-003)
Testing for Exposed Session Variables (OTG-SESS-004)
Testing for Cross Site Request Forgery (CSRF) (OTG-SESS-005)
Testing for logout functionality (OTG-SESS-006)
Test Session Timeout (OTG-SESS-007)
Testing for Session puzzling (OTG-SESS-008)
Input Validation Testing
Testing for Reflected Cross Site Scripting (OTG-INPVAL-001)
Testing for Stored Cross Site Scripting (OTG-INPVAL-002)
Testing for HTTP Verb Tampering (OTG-INPVAL-003)
Testing for HTTP Parameter pollution (OTG-INPVAL-004)
Testing for SQL Injection (OTG-INPVAL-005)
Testing for LDAP Injection (OTG-INPVAL-006)
Testing for ORM Injection (OTG-INPVAL-007)
Testing for XML Injection (OTG-INPVAL-008)
Testing for SSI Injection (OTG-INPVAL-009)
Testing for XPath Injection (OTG-INPVAL-010)
IMAP/SMTP Injection (OTG-INPVAL-011)
Testing for Code Injection (OTG-INPVAL-012)
Testing for Local File Inclusion
Testing for Remote File Inclusion
Testing for Command Injection (OTG-INPVAL-013)
Testing for Buffer overflow (OTG-INPVAL-014)
Testing for Heap overflow
Testing for Stack overflow
Testing for Format string
Testing for incubated vulnerabilities (OTG-INPVAL-015)
Testing for HTTP Splitting/Smuggling (OTG-INPVAL-016
Testing for Error Handling
Analysis of Error Codes (OTG-ERR-001)
Analysis of Stack Traces (OTG-ERR-002)
Testing for weak Cryptography
Testing for Weak SSL/TLS Ciphers, Insufficient Transport Layer Protection (OTG-CRYPST-001)
Testing for Padding Oracle (OTG-CRYPST-002)
Testing for Sensitive information sent via unencrypted channels (OTG-CRYPST-003)
Business Logic Testing
Test Business Logic Data Validation (OTG-BUSLOGIC-001)
Test Ability to Forge Requests (OTG-BUSLOGIC-002)
Test Integrity Checks (OTG-BUSLOGIC-003)
Test for Process Timing (OTG-BUSLOGIC-004)
Test Number of Times a Function Can be Used Limits (OTG-BUSLOGIC-005)
Testing for the Circumvention of Work Flows (OTG-BUSLOGIC-006)
Test Defenses Against Application Mis-use (OTG-BUSLOGIC-007)
Test Upload of Unexpected File Types (OTG-BUSLOGIC-008)
Test Upload of Malicious Files (OTG-BUSLOGIC-009)
Client side Testing
Testing for DOM based Cross Site Scripting (OTG-CLIENT-001)
Testing for JavaScript Execution (OTG-CLIENT-002)
Testing for HTML Injection (OTG-CLIENT-003)
Testing for Client Side URL Redirect (OTG-CLIENT-004)
Testing for CSS Injection (OTG-CLIENT-005)
Testing for Client Side Resource Manipulation (OTG-CLIENT-006)
Test Cross Origin Resource Sharing (OTG-CLIENT-007)
Testing for Cross Site Flashing (OTG-CLIENT-008)
Testing for Clickjacking (OTG-CLIENT-009)
Testing WebSockets (OTG-CLIENT-010)
Test Web Messaging (OTG-CLIENT-011)
Test Local Storage (OTG-CLIENT-012)
Report
Executive Summary
Test Parameters
Findings
|
|
grav |
Grav: Creating websites with a flat-file, no-database CMS |
7 hours |
Grav is an open-source, flat-file CMS (content management system). It comes with a powerful Package Management System to allow for simple installation and upgrading. Grav's underlying architecture uses well-established and best-in-class technologies to ensure that Grav is simple to use and easy to extend. As Grav is a flat file CMS, no database is required; this makes setting up a new site a very smooth process.
This training introduces the fundamentals of Grav CMS and walks participants through the creation of a Grav-based website. By the end of this training, participants will have the knowledge and practice to deploy their own Grav website.
Audience
Web application developers
Format of the course
This training has a heavy emphasis on hands-on practice. Most of the concepts are discovered through samples, exercises and hands-on development.
Introduction
Grav vs Wordpress, Joomla and Drupal
Setting Up Grav CMS
Using the Admin Panel
Using the Grav CMS CLI
Creating web content in Grav CMS
Working with Grav CMS templates
Creating essential theme files
Working with CSS
Setting Up a Blog
Working with the post template
Creating a modular home page in Grav CMS
Obtaining themes and skeletons from GetGrav.org
Debugging and logging
Adding plugins and themes
Working with Blueprints
Migrating from Wordpress
Updating Grav CMS
Performance and caching
Troubleshooting
Contributing to the Grav CMS project
Closing remarks |
