Perl Training Overview

Perl 5 & Perl 6 Training

Whether its Perl 5 or Perl 6 training you are looking for we have a course that will meet your requirements. Our Perl training courses cover fundamentals and advanced Perl 5 and Perl 6 topics for the beginner or the more experience Perl coder.

Although Perl 5 and Perl 6 can be considered different languages Perl 6 is described as "a Perl language" in that there is more than one way to do the same thing!

Perl Fundamentals Training

Our Perl fundamentals training deals with the basic of Perl syntax, data types such as list, arrays and hashes , operations and Perl functions as well as the famous Perl regular expressions.

Perl Advanced Training

Our Perl advanced training covers Perl modules, database integration and network programming. It also goes into greater depth with array and list operations. context and reference types.

Perl 6 Fundamentals Training

Our Perl 6 fundamentals uses the Rakudo Perl 6 compiler and covers the Perl 6 type system. operators. array, list and sequences. It also highlights the differences between Perl 5 and Perl 6.

Perl 6 Advanced Training

The Perl 6 advanced course covers advanced regular expressions, writing modules, asynchronous communications, phasers, multi-dispatch, grammars and reflection.

Testimonials

What our alumni have to say about our training   

Perl 5 Training Courses

Perl 5 Training Objectives

Perl Fundamentals Objectives

  • Introduction to Perl
    • Introduction to Perl
    • History of Perl
    • Description of Perl
    • Basic concepts
  • Scalar Data
    • Scalar values
    • Operators
    • Scalar variables
    • Operations on scalar of variables
    • Safe coding practices
  • Arrays
    • Array variables
    • Array access
    • Using STDIN with an array
  • Branching and Looping
    • Statement blocks
    • Statements
    • If/unless conditionals
    • While/until loops
    • For and for each loops
    • Do loops
  • Hashes
    • Hash what is it?
    • Operators
    • Hash Slices
  • Input and Output
    • Input operators
    • Output operators
    • Print / prints
    • Here documents
  • Regular Expressions Part 1
    • Regular expressions
    • Patterns
    • Grouping patterns
    • Operator precedents
  • Regular Expressions Part 2
    • Matching operator variants
    • Substitutions
    • Other operators
    • Regular expression options
  • Functions
    • System and user defined functions
    • Return values and arguments
  • Passing values to Functions
    • Variable number of parameters
    • Pass by reference or value

 

Perl Advanced Objectives

  • Revision, and the Perl Environment
    • Course objectives
    • Perl documentation
    • Interpreter environment
    • Running a Perl script
    • Anatomy of a Perl script
    • Perl variables
    • Some short-cut operators
    • Lexical variables (1)
    • Controlling the interpreter - Pragmas
    • Always use strictures
    • Perl 5.10 - use feature
    • Lexical variables (2)
    • Lexical pragmas
    • Perl debugging
  • Context and Types
    • Reminder: variable definitions
    • Defined and undefined scalars
    • Undefining arrays and hashes
    • Predefined variables
    • Some useful literal constants
    • The DATA file handle
    • Here documents
    • Arrays and lists
    • Comma operator
    • Array slices
    • Array magic
    • Remember hashes
    • Hash slices
    • The joy of x
    • Context and type conversions
  • Further Flow Control
    • Revision - basic conditionals
    • Revision - Boolean and logical operators
    • Revision - what is truth?
    • Smart match operator ~~
    • Smart match operator is smart
    • Short circuit operators
    • Labels and loop jump statements
    • The sad case of switch/case
    • A kind-of case statement
    • Pre-5.8 use of labels and last
    • Switch / case statement (5.8)
    • The given statement - 5.9 or later
    • Loop jump statements: continue
    • Advanced for loops
    • In-line conditional operator
    • Defined-Or Operator // (5.10)
    • File condition functions
    • Evaluating file conditions
  • References
    • What are references?
    • Uses of references
    • Creating references
    • Using references
    • Dereferencing array and hash references
    • Using references
    • Examining references
    • Complex data structures
    • Data::Dumper
    • Reference counting
  • Advanced Subroutines
    • Calling a subroutine
    • Subroutine return values
    • Subroutine return values - context
    • Subroutine arguments
    • Named and default parameters
    • Parameter passing - by value?
    • Parameter passing - by reference?
    • Parameter passing - by magic
    • Explicit pass by reference
    • Subroutine prototypes
    • Prototype syntax
    • Prototypes - automatic call by reference
    • References to subroutines
    • Closures
    • Subroutine as an lvalue
  • Advanced List Functions
    • Sorting
    • Revision - array and list functions
    • List functions: reverse, sort, grep, map
    • The sort function
    • Custom sort order
    • Avoiding sort
    • Sorting hashes
    • map
    • grep
  • Input and Output
    • File handles
    • New file handles
    • Scalar variables with handles
    • The magic variable $/
    • The 'flip-flop' operator
    • Formatted output - printf
    • Changing the default output handle
    • Alternative IO functions
    • File::Find
    • The Perl IO model
    • Using sysopen
    • Reading and writing files
    • Random access
  • Advanced Regular Expressions
    • Regular Expressions in Perl
    • Review: Perl RE meta-characters
    • Regular expression quoting
    • Modifiers for regular expressions
    • Review of side-effect variables
    • Back-references
    • More capturing groups
    • Non-capturing groups
    • Other capturing variables
    • Named captures (5.10)
    • Minimal matches
    • Multi-line matches
    • Alternatives to ^ and $
    • Global matches
    • Global match progress
    • Comments in Regular Expressions
    • Substitution with interpolation
    • Look-around assertions
    • Substitution using expressions
  • Modules
    • Splitting into modules
    • Using modules
    • The library directories
    • Using subroutines from modules
    • Writing modules: structure of a module
    • Namespaces
    • Using modules without symbol export
    • Example of unconditional export
    • Example of on-demand export
    • Symbol export using tags
    • BEGIN and END blocks
    • Order of BEGIN and END blocks
    • Attaching a module with require
    • Standard modules
    • Adding modules
    • Other ways of getting modules
  • Handling Errors and Exceptions
    • Warnings and diagnostics
    • Controlling warnings
    • Error handling
    • Errno module
    • Error handling - Carp
    • Dealing with undef
    • eval
    • eval syntax
    • Error trapping using eval
    • Dying with a reference
    • Signal handling in Perl
    • Alternative signal handling
    • Sending signals
    • Timing out - alarm
    • Fake signals
    • warn and carp
    • Processing the warn and die signals
    • Errors in child processes
  • Object Oriented Programming
    • Review of Object Oriented Programming
    • Object-Oriented terminology
    • OO features in Perl
    • Basic object usage
    • Objects are references
    • Implementing objects
    • Accessing object fields
    • Constructors
    • Implementing object methods - details
    • Method calls
    • Destructors
    • Method inheritance
    • The parent pragma - 5.10.1 or later
    • Inheriting constructors
    • To OO, or not to OO?
  • Database Interfacing Using DBI
    • Perl and databases
    • The tie interface
    • Tie-ing a hash to a GDBM file
    • DBI and DBD
    • DBI objects and methods
    • Connect and disconnect
    • Driver issues with MS SQL Server
    • Options for connect
    • Life cycle of a statement
    • Placeholders
    • Reading information
    • Fetching database meta-data
    • Repeated statement execution
    • Other database handle methods
    • Database capabilities
    • Manual transaction control
    • Error handling
    • Calling a stored procedure
    • Other DBI drivers
    • Yet more DBI drivers
  • Network and Web Programming
    • Networking concepts: layers and sockets
    • Sockets are file handles
    • A basic client
    • A basic server
    • Network modules: FTP client
    • Network modules: web client
    • Network modules: sending mail
    • Program generated web pages
    • Secure Perl - taint mode
    • Running a CGI script
    • Using HTML from Perl
    • A simple CGI script
    • CGI.pm basic functions
    • Form handling using CGI.pm
    • Templates
    • Frameworks

Perl 6 Training Courses

Perl 6 Training Objectives

  • Perl 6 Introduction
    • Language specification vs. implementation
    • Installing the Rakudo Perl 6 compiler
    • Understanding the Rakudo Perl 6 stack
    • Hello, world
    • Statements
    • The REPL
    • The zef module installer
    • Where to find documentation and assistance
  • Values
    • Numerics
    • Values know WHAT they are
    • Strings
    • Booleans
  • Variables
    • Scalar variables
    • Array variables
    • Hash variables
    • Assignment vs. binding
    • Dynamic variables
    • Interpolation
  • Basic I/O
    • slurp and spurt
    • Working with file handles
    • Encodings
  • Control flow
    • Iteration with the for loop
    • Conditionals
    • Definedness
    • More loopy skills
  • Basic testing
    • Testing culture
    • The Test module
    • The most common test assertions
    • plan vs. done-testing
  • Routines and blocks
    • Subroutine declaration
    • Signatures, parameters, and arguments
    • Return type constraints
    • Blocks and pointy blocks
    • Placeholder parameters
    • Unpacking and destructuring
  • Smart matching
    • The ~~ and !~~ operators
    • given, when, and the topic variable revisited
    • where traits
    • subset types
  • Exception essentials
    • die and CATCH
    • Built-in exception types
    • Test assertions relating to exceptions
  • Object orientation
    • Classes, attributes, and methods
    • Roles and flattening composition
    • Inheritance
    • Custom exception classes
    • Parametric roles
    • The FALLBACK method
    • Introspection
  • Basic text pattern matching
    • New regex syntax overview
    • Literals
    • Quantifiers
    • Character classes, built-in and user-defined
    • Grouping and capturing
    • Named captures
    • Alternations: sequential and longest prefix
    • Factoring out patterns into named regexes
    • Look ahead and other zero-width assertions
  • Parsing with grammars
    • What is a grammar?
    • Start at the TOP
    • The parse and subparse methods
    • token vs regex
    • rule and automatic whitespace handling
    • make and .made
    • Action classes
  • Creating modules
    • Modules, compilation units, and distributions
    • The export trait and export tags
    • use and importing by tag
    • The EXPORT sub for custom exporting
    • The META6.json file
  • Multiple dispatch
    • By arity
    • By type
    • By smart matching
    • By structure
    • Insight: operators are just multi-dispatch subroutines
    • The MAIN subroutine
  • Sequences and laziness
    • Array, List, and Seq
    • Common list-processing operations: map, grep, unique, and more
    • The reduce, zip, and cross meta-operators
  • Concurrency
    • Promise and await
    • Reactive programming with Supply
    • Working with processes asynchronously
    • The supply/react/whenever syntax
  • Functional Programming
    • Functions are first-class citizens
    • Anonymous functions
    • Chaining
    • Feed Operator
    • Hyper operator
    • Junctions
    • Lazy Lists
    • Closures
  • Native Calling Interface
    • Calling a function
    • Renaming a function
    • Passing Arguments
    • Returning values
    • Types

 

About Us

About Us

Jumping Bean is an open source integration and training company that has been delivery solutions to customers for over 17 years.

Our services include:

  • Support
    • 24x7SLA based
    • Ad-hoc support,
  • Security consulting
    • Vulnerability scans,
    • Server hardening
    • Penetration tests
  • Training
    • Linux
    • Java
    • DevOps
    • Cloud

Long-Term Partnerships

We build long relationships with our customers which helps us better  understand their needs and offer customised solutions and training to meet their business requirements.

Our clients include large and small businesses in South Africa and across the globe.  We offer both remote and on-site support.

Passion for Technology

We are passionate about open source and love living on the bleeding edge of technology innovation. Our customers lean our our practical experience with emerging technologies to ensure they get the benefits of early adopters and avoid the pitfalls.

Training 100% Money Back Guarantee

We are so confident of the quality of our training that our courses carry a 100% money back guarantee. If at the end of the first day of training you are unsatisfied with the course we will refund 100% of your spend no questions asked!

Our Clients

Our Clients

 

 

 

 

 

Contact Us Anchor Tag

Please contact us for any queries via phone or our contact us form. We will be happy to answer your questions!

Jumping Bean
Appian Place, 373 Kent Ave
Ferndale,
2194
Tel: +2711-781 8014

Contact Form

Jumping Bean Contact Form!