1. 1. Advanced Perl
2. 2. Perl References
3. 1. 2.1. Uses cases for references
   2. 2.2. References
   3. 2.3. Array References
   4. 2.4. Hash References
   5. 2.5. Scalar references
   6. 2.6. Subroutine references
   7. 2.7. Passing values to a function
   8. 2.8. Add two (or more) arrays
   9. 2.9. Add two arrays
   10. 2.10. Array References
   11. 2.11. Process arrays without copying
   12. 2.12. Scope of variables
   13. 2.13. Reference counting
   14. 2.14. More Reference Counting
   15. 2.15. Process arrays without copying even the return values
   16. 2.16. Debugging (pretty printing)
   17. 2.17. Change values in a reference
   18. 2.18. Exercise: double numbers
   19. 2.19. Exercise: Add many arrays
   20. 2.20. Exercise: Function to compare two hashes
   21. 2.21. Solution: Double numbers
   22. 2.22. Solution: Add many arrays
   23. 2.23. Solution: Add many arrays
   24. 2.24. Solution: Function to compare two hashes
   25. 2.25. Anonymous Arrays
   26. 2.26. Array of Arrays
   27. 2.27. Array of Arrays (AoA)
   28. 2.28. Many dimensional arrays
   29. 2.29. Anonymous hashes
   30. 2.30. Hash of Hashes (HoH)
   31. 2.31. More complex data structures
   32. 2.32. Memory leak with cross references
   33. 2.33. Memory leak with cross references - weaken
   34. 2.34. Read CSV file
   35. 2.35. Exercise: read in an ini file
   36. 2.36. Exercise: improve the csv reader
   37. 2.37. Solution: Read ini file
   38. 2.38. Solution: improve the csv reader
   39. 2.39. autovivification
   40. 2.40. Scalar references in Getopt::Long
   41. 2.41. Anonymous subroutines
   42. 2.42. Uses of Subroutine references
   43. 2.43. Exercise: DNA Sequence Analyzer
   44. 2.44. Solution: DNA Sequence Analyzer
   45. 2.45. Exercise: DNA Sequence Analyzer with callback
   46. 2.46. Solution: DNA Sequence Analyzer with callback
   47. 2.47. Exercise: DNA Sequence Analyzer with shortcut
   48. 2.48. Solution: DNA Sequence Analyzer with shortcut
   49. 2.49. Dispatch Table
   50. 2.50. Dispatch Table using symbolic references
   51. 2.51. The ref() function
   52. 2.52. Copy a data structure
   53. 2.53. Deep copy
   54. 2.54. Deep copy - Storable dclone
   55. 2.55. Serialization
   56. 2.56. Data::Dumper
   57. 2.57. Data::Dumper both dump and restore
   58. 2.58. Storable
   59. 2.59. Storable in memory freezing
   60. 2.60. YAML
   61. 2.61. YAML in one file
   62. 2.62. JSON in one file
   63. 2.63. Main uses of references
   64. 2.64. Exercise: save ini and csv as YAML
   65. 2.65. Exercise: Create a cache for NetSlow
   66. 2.66. Exercise: create a function that generates numbers multipliers
   67. 2.67. Solution: save ini and csv as YAML
   68. 2.68. Solution: Create a cache for NetSlow
   69. 2.69. Solution: NetSlow cache with timeout
   70. 2.70. Resources
4. 3. Processes and signals
5. 1. 3.1. Signals and the kill function
   2. 3.2. Catch signals
   3. 3.3. Exercise: Catch ctrl-c and ask continue or terminate?
   4. 3.4. Solution: Catch ctrl-c and ask
   5. 3.5. Graceful termination of process
6. 4. Advanced slides
7. 1. 4.1. Always use strict and warnings
   2. 4.2. Avoid warnings
   3. 4.3. Turn off warnings selectively and in a small scope
   4. 4.4. Catch and log warnings
   5. 4.5. splain and use diagnostics
   6. 4.6. Fatal warnings
   7. 4.7. Logging Exceptions
   8. 4.8. Always open files in the new way
   9. 4.9. Array slices
   10. 4.10. Array slices on the fly
   11. 4.11. Hash slices
   12. 4.12. Hash slices in assignment
   13. 4.13. splice
   14. 4.14. LIST and SCALAR context
   15. 4.15. wantarray
   16. 4.16. wantarray example
   17. 4.17. Slow sorting
   18. 4.18. Speed up sorting
   19. 4.19. Schwartzian transformation
   20. 4.20. Compilation phases: BEGIN, CHECK, INIT, END
   21. 4.21. AUTOLOAD
   22. 4.22. Static variable
   23. 4.23. Exercise: create counter
   24. 4.24. Solution: create counter
   25. 4.25. Saved variable: local
   26. 4.26. autodie
   27. 4.27. Modern::Perl
   28. 4.28. Perl::Critic
   29. 4.29. Perl::Tidy
   30. 4.30. caller
   31. 4.31. Log::Dispatch
   32. 4.32. Log::Log4perl easy
   33. 4.33. Exercise: Log::Dispatch
   34. 4.34. Solution Log::Dispatch
8. 5. Functional Programming in Perl
9. 1. 5.1. Programming Paradigms
   2. 5.2. Functional programming
   3. 5.3. grep
   4. 5.4. grep to filter files based on modification date
   5. 5.5. Imitating the Unix/Linux grep command in Perl
   6. 5.6. map
   7. 5.7. Use map to filter values
   8. 5.8. Map to add more elements
   9. 5.9. Use map to filter and enrich
   10. 5.10. Create a hash from an array using map
   11. 5.11. Unique values
   12. 5.12. Unique values - improved
   13. 5.13. Unique values using grep
   14. 5.14. Uniq with List::MoreUtils
   15. 5.15. Closures
10. 6. Perl Libraries and Modules
11. 1. 6.1. Lack of code reuse
    2. 6.2. Perl library (perl4 style)
    3. 6.3. Problems with Libraries
    4. 6.4. Prefix everything with unique name
    5. 6.5. Namespaces
    6. 6.6. Solution with namespace
    7. 6.7. Modules
    8. 6.8. Packages, @INC and Namespace hierarchy
    9. 6.9. use, require and import
    10. 6.10. Export - Import
    11. 6.11. Restrict the import
    12. 6.12. On demand Import
    13. 6.13. Importing
    14. 6.14. Modules - behind the scene
    15. 6.15. Tools for packaging and distribution
    16. 6.16. Packaging modules
    17. 6.17. Makefile.PL of ExtUtils::MakeMaker
    18. 6.18. Makefile.PL of Module::Install
    19. 6.19. Build.PL of Module::Build
    20. 6.20. Changes and README
    21. 6.21. MANIFEST and MANIFEST.SKIP
    22. 6.22. A script
    23. 6.23. A module
    24. 6.24. Packaging with Makefile.PL
    25. 6.25. Packaging with Build.PL
    26. 6.26. A test file
    27. 6.27. Writing Tests
    28. 6.28. Exercises: Multiply numbers
    29. 6.29. Solution: Multiply numbers
    30. 6.30. Overview
12. 7. Error Handling
13. 1. 7.1. Returning error status or throwing exception?
    2. 7.2. eval block
    3. 7.3. Exception handling with Try::Tiny
    4. 7.4. Carp
    5. 7.5. Carp::Clan
    6. 7.6. The problem with die and croak
    7. 7.7. Exception::Class
    8. 7.8. Processing exceptions
    9. 7.9. Exercise
    10. 7.10. Solution
    11. 7.11. Solution
14. 8. Introduction to Moose
15. 1. 8.1. Moose Constructor
    2. 8.2. Test Moose Constructor
    3. 8.3. Moose Attribute
    4. 8.4. Test Moose Attribute
    5. 8.5. Moose Attribute Type
    6. 8.6. Test Moose Attribute Type
    7. 8.7. Moose Attribute Type class
    8. 8.8. Test Moose Attribute Type class
    9. 8.9. Moose Attribute - create your own subtype
    10. 8.10. Test Moose Attribute - create your own subtype
    11. 8.11. Moose Attribute - coercion
    12. 8.12. Test Moose Attribute - coercion
    13. 8.13. Moose Enumeration
    14. 8.14. Moose Attributes Overview
    15. 8.15. Inheritance
    16. 8.16. Testing Inheritance
    17. 8.17. MooseX::StrictConstructor
    18. 8.18. Testing Strict attributes
    19. 8.19. Encapsulation
    20. 8.20. Class data
    21. 8.21. Special actions during object construction
    22. 8.22. Singleton in Moose
    23. 8.23. Destructor in Moose
16. 9. Running subprocess
17. 1. 9.1. Possibilities
18. 10. Prima
19. 1. 10.1. Prima Hello World
20. 11. wxPerl - wxWidgets for Perl
21. 1. 11.1. wxPerl - Hello World
22. 12. Microsoft Windows
23. 1. 12.1. Win32 examples
24. 13. PSGI
25. 1. 13.1. PSGI Cookbook
26. 14. Parallel processing
27. 1. 14.1. Types of problems
    2. 14.2. Types of solutions
    3. 14.3. Tasks
    4. 14.4. Measurements on 32 core
    5. 14.5. Measurements on 4 core
    6. 14.6. The Hardware
    7. 14.7. Installations
    8. 14.8. Fork
    9. 14.9. Fork with functions details
    10. 14.10. Fork random and seed
    11. 14.11. Fork without functions
    12. 14.12. Fork details
    13. 14.13. Fork many
    14. 14.14. Parent process ID
    15. 14.15. pstree
    16. 14.16. htop
    17. 14.17. Active non-blocking waiting with waitpid
    18. 14.18. Non-blocking waiting with waitpid - multiple forks
    19. 14.19. Non-blocking waiting, rerun on failure
    20. 14.20. Functions to be speed up
    21. 14.21. Counter process
    22. 14.22. Forked counter process
    23. 14.23. Prepare CSV files
    24. 14.24. Process CSV files
    25. 14.25. Use Parallel::ForkManager
    26. 14.26. Return values using Parallel::ForkManager
    27. 14.27. Forked process CSV files
    28. 14.28. HTTP GET
    29. 14.29. Forked HTTP requests
    30. 14.30. Exercise: Process Excel files
    31. 14.31. Exercise: Web crawler
    32. 14.32. MCE - Many-Core Engine
    33. 14.33. MCE - map running in parallel
    34. 14.34. MCE - map with init
    35. 14.35. other modules
28. 15. Database access using Perl DBI
29. 1. 15.1. Architecture of a DBI Application
    2. 15.2. Create Sample Database
    3. 15.3. Connect to database
    4. 15.4. SELECT with one result
    5. 15.5. SELECT with more results
    6. 15.6. SELECT, prepare with placeholders
    7. 15.7. SELECT, using hashref
    8. 15.8. INSERT
    9. 15.9. UPDATE
30. 16. Advanced Database access using Perl DBI
31. 1. 16.1. Data integrity
    2. 16.2. Transactions
    3. 16.3. Sample database creation
    4. 16.4. Disconnect from the database
    5. 16.5. Attributes
    6. 16.6. Error handling
    7. 16.7. Debugging (Trace levels)
32. 17. Database access using DBIx::Class
33. 1. 17.1. DBIx::Class
    2. 17.2. Create Sample Database
34. 18. Internet Explorer
35. 1. 18.1. Win32::IE::Mechanize
    2. 18.2. Accessing Google
    3. 18.3. Examples
36. 19. X-Windows
37. 1. 19.1. X11
    2. 19.2. X11 Tools
    3. 19.3. X11::GUITest
    4. 19.4. LDTP - Linux Desktop Testing Project
    5. 19.5. Manual steps
    6. 19.6. X11: Launch the application
    7. 19.7. Let's see the coordinates
    8. 19.8. Where is this top left corner ?
    9. 19.9. And let's see the rest of the coordinates
    10. 19.10. Smooth on the edges
    11. 19.11. Closing the window
    12. 19.12. Placing the cursor on one of the buttons and clicking on it
    13. 19.13. So let's do all the calculations
    14. 19.14. Fetch the list of Child Windows
    15. 19.15. Locate the Child Windows
    16. 19.16. Using the keyboard
    17. 19.17. Separate the keystrokes
    18. 19.18. Full solution for xcalc