Perl  & Raku Training

Whether it's Perl or Raku 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 experienced Perl coder.  Although Perl and Raku can be considered different languages Raku 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 basics of Perl syntax, data types such as lists, arrays, 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.

Raku Fundamentals Training

Our  Raku training covers the Raku-type system. operators. array, list, and sequences. It also highlights the differences between Perl 5 and  Raku.

Raku Advanced Training

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

Perl  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
    • 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
    • Switch / case statement
    • The given statement
    • Loop jump statements: continue
    • Advanced for loops
    • In-line conditional operator
    • Defined-Or Operator //
    • 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
    • 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
  • 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

Raku Training Objectives

  • Raku  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

raku mascot

 

Our Clients

Absa Bank Dimension Data Teraco Discovery Health South African Revenue Service First National Bank Allan Grey multichoice CSIR Standard Bank University of Johannesburg MTN Mr Price

About Us

jumping bean training room

Jumping Bean is an open-source integration & training company that's been delivering solutions to customers for over 20 years.

Our services include:

Linux

  • SLA support
  • Adhoc support
  • Hardening
  • Solutions architecture

Postgres

  • SLA based support
  • Implementation support
  • Solutions Architecture
  • Performance tuning 

DevOps

  • Advisory services
  • Implementation support
  • Consulting
  • SLA support
  • Training 

Big Data

  • Google & AWS Big Data support
  • Data flow architecture
  • Implementation support
  • Training

Security

  • Advisory Services
  • SOC service
  • Security Audits & Reviews
  • Training 

Software Development

  • Mobile Apps
  • Enterprise Apps 

Cloud Consulting

  • Migration
  • Cloud provider support
  • Workflow architecture
  • Automation
  • Big Data
  • Containerisation

Long Term Partnerships

We build long relationships with our customers that helps improve our understanding of their needs. We offer customised solutions & training to meet business requirements.

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

Passion for Technology

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

Contact Us

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

3 Appian Place,373 Kent Ave
Ferndale,

2194 South Africa
Tel: +2711-781 8014
ZA

Contact Form

Jumping Bean Contact Form!

Contact Form