Conference in the Cloud (A Perl and Raku Conference)

All are welcome! Come hang out and chat with folks gearing up for the conference!

Meeting ID: 960 3224 7965

BOF stands for Birds of a Feather. These are informal get-togethers planned by attendees and can be on any topic, technical or not. Please see the wiki or #cic-hallway in Slack in order to plan or attend the meetings.

Where is Perl going - what's going to happen in the upcoming year or two or three.

An intro to Test2::Aggregate, an aggregator module that can work with any test framework, particularly Test2::Suite, with the potential to dramatically increase the speed of tests - especially large volumes of small unit tests. There will be a focus on how to start integrating the module into a test suite without disrupting the workflow, how it can benefit your CI pipeline and how to deal with various caveats of aggregation. Additionally, various other ways to use the module will be presented, such as profiling, testing flakiness / finding conflicts, generating reports, testing aggregation etc.

3 security doors, a PC with no external access, and terabytes of semi-structured data needing parsing with big money riding on it. Would Perl be up for the challenge?

The twist will be revealed in the talk (it’s a doozy).

A large number of financial documents needed parsing. Accuracy was mission critical and money was literally riding on it. There was no specification and the meaning of some data was not even known to our client contacts. Many many years of data. The format shifted over time. It’s in a binary print format I had never heard of.

Would a very loose Backus-Naur Form approach work? Discuss.

We plan to have a zoom session open with available break out rooms for anyone who doesn't have a talk they're interested in attending.

In this talk I’ll show how I’ve used Perl and Raspberry Pi’s to build various data loggers for our research institute, including greenhouse gas measurements from an airplane, battery-powered CO2 loggers with a Mojolicious interface, and more.
Slides: https://bit.ly/2Yko3PH

To display weather information, web pages and apps want access to my location data. I don't want to share my location data. My solution is to prepare the Free data from the German Weather Service myself and to deliver it via a small, offline-capable webpage/webapp/PWA to my mobile phone.

Slides: https://corion.net/talks/personal-weather-pwa/personal-weather-pwa.odp

Kevin A. McGrail will discuss his tips for Secure Programming in any language but with Perl specifics. He will cover the following topics: CIA Passphrases not passwords Salting and Hashing Support MFA Think Evil SQL Placeholders Do NOT trust User Data Password Reset Risks Error Message Risks Logging Fail2ban POLP Encryption Incident Response Plans Usenix Code of Ethics Virgil, Cyph and Virtru NVDs & CVEs Automation Scrums for Security Secure SDLC SAST/DAST/IAST Software EOL Privilege Elevation QA Process Automation

And more if time permits!

Mojolicious has added industry standard features like Promises/A+ and async/await support. Those alone make writing asynchronous web applications much easier than it used to be, indeed its a whole new ballgame. I’ll cover some common async needs and their related patterns with my usual style of lots of example code that’s all available to run from the repo (and as always, including tests). I’m excited to share the new features (and a few old favorites) with everyone!

Repository: https://github.com/jberger/AwaitingMojolicious
Slides: https://jberger.github.io/AwaitingMojolicious
Recording: https://www.youtube.com/watch?v=I5xS2NcMzJU

https://speakerdeck.com/util

Under-embraced: Regexps, Deep data structures, Trees.
They all seem hard to learn, and hard to read, with minimal benefit.
They actually make code _more_ readable.
Usually :^)
This is their intro, via refactoring instead of examples, with clear on-ramps, and how to tell when they are worth learning.

Let’s write Perl bindings in WebAssembly (Wasm)! You’ve heard of WebAssembly: a portable bytecode that facilitates the implementation of high-performance applications inside web pages, but it is also useful for writing fast sandboxed extensions in a number of programming languages, including Perl.

WebAssembly (Wasm) was developed as a fast, safe, portable bytecode that could be used by web browsers in situations where plain JavaScript is not appropriate. It can also be useful in server applications, where the sandboxed nature of the technology allows running code that might be untrusted or might misbehave in subtle ways. As the applications for this technology are growing, a number of languages are getting their own WebAssebly interfaces that allow them to write fast, safe and portable extensions in any of the growing list of languages that can target WebAssembly, including Rust, Go and C.

In this talk I will discuss the basics of using WebAssembly using Wasmtime, an open source WebAssembly run-time. I’ll be focusing on using it from Perl using Wasm::Wasmtime, but will also touch briefly on how easily you can use a WebAssembly extension compiled just once, in a number of different languages, like Python or Node.js. We will spend some time comparing and contrasting using WebAssembly with related technologies that cross the language barrier like XS and FFI. I’ll also discuss WebAssebly techniques and technologies that I hope will be useful in Perl in the near future. Future specifications like WebAssebly Interface Types that should make it easier for different languages to talk to each other using higher level types. There should also be time to talk about future technologies like Lucet, the WebAssebly native compiler, for even faster execution.

The "modulino" format allows a command line script to behave like a module that can be tested with familiar test harness tools (i.e. Test::More and Test::MockModule) without executing it, often achieving very high coverage numbers. It is only natural to bring Moo to the game.

The basic idea of a “modulino” is to take advantage of the caller() function to determine if a script is being run from the command line or being included by a require statement. This allows the code to behave as either a normal script or as a module. It is the latter behavior that enables a modulino to be fully testable without having to execute it and capture the output somehow. It allows full unit testing with tools such as Test::More and Test::MockModule.

Moo brings a well-known OO framework to the party to help organize the script more like a module and provide command line parameters as object attributes.

This talk will demonstrate with simple scripts how Moo and Getopt::Long can play nice with each other and how the modulino structure benefits testing. A Role will be introduced, MooX::Role::CliOptions, to show how coding standards can be established for standard command line options.

This talk will show the most important new developments in web dev, the history of these technologies, how and why they've been improved, current best practices, and things to watch for in the future. Emphasis will be on features usable today on any website without complex development frameworks.

Are you struggling to stay up-to-date with the state of web development? Are you interested in why the web sites you maintain are using tables everywhere? Would you like to know some of the wonderful things that have been created in the last 30 years to make web development easier?

In this talk, Doug Bell will show the most important new developments in web technologies. In addition, he’ll explore the history of those technologies, how they’ve been improved, current best practices, and things to watch for in the future.

If you’re a former web developer looking to see what’s new, or a current web developer looking to see how we got here, this talk is for you. Emphasis will be on features usable today on any website without complex development frameworks. Some experience in HTML, CSS, and JavaScript will be helpful to understand the example code.

Classification of types of autonomous testing: - Types of functionality recognition/code generation + Discovery/rules-based + Pattern-recognition-based + Combinatorial-based - Types of testing: + Regression + Discovery

How do different types of systems under test affect tests support? What types of autonomous tests are one-off and what types are supportable.

Will walk through use cases for each type and when they are applicable. Talk about cases where all of them are not applicable. How autonomous testing can be integrated into CI/CD. Where integration to CD is possible and where it is not possible.

You’ll see different examples in practice.

Public speaking. Team management. Efficiency. Problem Solving. Leadership. All these terms commonly refer to the workplace, and for most people, they are a challenge.
These same words apply to the orchestra. Musicians deal with and solve these issues on a daily basis. What can we learn from them?

An orchestra is usually given as the perfect example of harmony. Very different instruments, sometimes very far from one another, a different music sheet, and yet, unity is achieved. Music is made, and it’s beautiful. Achieving this harmony is not easy, and requires a lot of work from everyone. Being a good musician is not enough. Being able to listen to the other musicians, focusing, following the conductor during rehearsals and on concert night, managing stage fright; all these steps are necessary, and by no means easy. Yet, musicians do it every day. The qualities they develop can be transferred to the work place: solving conflicts, overcoming the fear of public speaking, managing opposite points of view and personalities, creating a positive relationship between a manager and his team… There is lot to learn from the orchestra!

Submit a lightning talk

Scroll down to see an explanation of the lightning talks.

The Schedule

--

Perl on a cell phone
Zachary Zebrowski

This talk will talk about running perl on an android chroot environment called termux.

https://www.youtube.com/watch?v=3nGCNrHXuqQ
https://docs.google.com/presentation/d/1mLj2dphTFOPwzlunNWbetfM0si_WhIlSeOrJXyqjWR4/edit?usp=sharing

--

Octology on GitHub and SourceForge
Pip Stuart

This talk is all about bolts of Lightning from the Perly-G8s in the Clouds. It is a detailed demonstr8ion of what new users will become capable of doing by exploring all that Octology has to offer. Enjoy!

--

SRCPans - a cunning plan for marketing Perl + Raku
Nigel Hamilton

Google associates search problems with solutions - it's an association engine. Search on Google for 'parse a CSV file'. Where is Perl? Where is Raku? CPAN and modules.raku.org are full of solutions! When programmers have a problem we want them to find Perl and Raku solutions.

SCRPans is a proposal for a new TPF sponsored code sharing site for Perl and Raku, powered by our community and backed by CPAN and modules.raku.org. Think .... Stackoverflow meets RosettaCode.
This talk presents a mock user interface and proposes an MVP site and next steps. Give your feedback. Leave search trails to Perl and Raku. Support SRCPans.

https://www.youtube.com/watch?v=VS_IS_omAV8
https://nigelhamilton.com/pages/talks

--

Yes YOU can!
Fritz Zaucker

This talk will show a few examples of how we contribute to the development of Perl/Raku and demonstrate that YOU can as well.

https://www.youtube.com/watch?v=r7JyximgP-k

--

Competitively Min-Maxing your Diet w/Raku
Joshua Eric Turcotte

Coming out of the Code For NoVA (a Code for America member) where open sourced projects and programming training occur, an idea of mine found traction -- that being encouraging better eating/cooking habits by 'min-maxing' a recipe's statistics for cost, quality, and overall health. Throw in competition and not only may new recipes emerge that improve local health, but it might also encourage local providers to ramp up growing healthy produce rather than processed junk.
While I'm more comfortable pursuing this with perl5, a participating teacher wanted to throw his highschool students at the idea for their classwork and wanted 'in on the ground floor' with a new language, and so Raku was adopted.
Very early stages yet, but it's worth a try.

https://www.youtube.com/watch?v=iAUUb7QU51I
https://docs.google.com/presentation/d/1PnjI-j6c7LUkjU-oGdGNAGCRSsjjLB6oUmGUtpMg9oU/edit?usp=sharing

--

Talk to Your Duck
Kevin A. McGrail

A short introduction to the benefits of talking to ducks and how it can improve your programming.

https://www.youtube.com/watch?v=CzXbp1C5zKs
https://docs.google.com/presentation/d/1rs7GmTcjFWeSwq8sS-FGzAvVQ9DX_vByOcmHxz3BN0E/edit?usp=sharing

------------------

These Lightning Talks may be serious, funny, or both. They may be given by experienced speakers already giving full length talks or by first time speakers just starting out (this is a great way to get started if you have something to say). If you are a first time speaker you will win a tie with an experience speaker when the schedule is made if it comes to it. Today's first time speaker could be tomorrow's keynote speaker.

We will have about 8-10 Lightning Talks of 5 minutes each day. Submit your talk through the submit talk link at top of this description. The first deadline is with the full length talks. The second deadline is one week before the conference starts and many proposals will be accepted. Usually at least two speaking spots on days 2 and 3 will be held open until the day before the talks to give you a chance to see something at the conference and put together a Lightning Talk response. However if you wait for the later deadlines note that there are fewer spots available and you are less likely to be accepted so please try to submit more than a week before the conference.  THIS YEAR WITH THE COMPLICATIONS OF ZOOM IT WOULD REALLY BE BEST IF YOU SUBMIT EARLY.  ALSO SEE THE BOTTOM OF THIS DESCRIPTION FOR SOME OTHER CHANGES.

In addition to the five minute Lightning Talks where you get to use your computer, slides, and any other tool, we will also have some Lightning Advertisements. These are only 30 seconds, you don't have to submit a proposal, you don't get any slides, and you don't get to share your screen. If you have a BOF to announce, an auction item to advertise or any other short message you can use the transition time that would be otherwise wasted between Lightning Talks to share your message. See below for how to give an ad this year.




Why Would You Want to do a Lightning Talk?

Maybe you've never given a talk before, and you'd like to start small. For a Lightning Talk, you don't need to make slides, and if you do decide to make slides, you only need to make three.

Maybe you're nervous and you're afraid you'll mess up. It's a lot easier to plan and deliver a five minute talk than it is to deliver a long talk. And if you do mess up, at least the painful part will be over quickly.

Maybe you don't have much to say. Maybe you just want to ask a question, or invite people to help you with your project, or boast about something you did, or tell a short cautionary story. These things are all interesting and worth talking about, but there might not be enough to say about them to fill up thirty minutes.

Maybe you have a lot of things to say, and you're already going to give a long talk on one of them, and you don't want to hog the spotlight. There's nothing wrong with giving several Lightning Talks. Hey, they're only five minutes.

On the other side, people might want to come to a lightning talk when they wouldn't come to a long talk on the same subject. The risk for the attendees is smaller: If the talk turns out to be dull, or if the person giving the talk turns out to be a really bad speaker, well, at least it's over in five minutes. With lightning talks, you're never stuck in some boring lecture for forty-five minutes.

Still having trouble picking a topic, here are some suggestions:

1. Why my favorite module is X.
2. I want to do cool project X. Does anyone want to help?
3. Successful Project: I did project X. It was a success. Here's how you could benefit.
4. Failed Project: I did project X. It was a failure, and here's why.
5. Heresy: People always say X, but they're wrong. Here's why.
6. You All Suck: Here's what is wrong with the our community.
7. Call to Action: Let's all do more of X / less of X.
8. Wouldn't it be cool if X?
9. Someone needs to do X.
10. Wish List
11. Why X was a mistake.
12. Why X looks like a mistake, but isn't.
13. What it's like to do X.
14. Here's a useful technique that worked.
15. Here's a technique I thought would be useful but didn't work.
16. Why algorithm X sucks.
17. Comparison of algorithms X and Y.

Of course, you could give the talk on anything you wanted, whether or not it is on this list. If we get a full schedule of nothing but five minutes of ranting and raving on each topic, a good time will still be had by most.



CHANGES THIS YEAR
As we are in the Cloud this year we will have to make a few changes from the normal arrangement.

• To speak you will need to be participating in the interactive Zoom version of the conference so be sure to register using the link at the top of the website.
• Traditionally we start the conference with the first day of lightning talks full and fill the rest of the slots during the conference.  We would really like to get most speakers selected and through a quick practice session on Zoom before the conference starts to avoid technical difficulties which will be much harder to gloss over in this environment.
• If you think you will have technical difficulties consider having a backup plan where someone else display your slides and you say when to go to the next one.  A nice firm 'ping' or 'beep' like in old AV displays in school in the pre internet era would make many in the audience think kindly of you.
• During the week before the conference you will get a chance to display a slide or two in a Zoom session for practice and to make sure your connection and camara are all set.  Talk with rGeoffrey in Slack or responding to your acceptance email to make arrangements.  You don't need your full set of slides during the practice, but a few slides in the correct program for a fair test would help.
• Traditionally time is marked by a bell at the one minute warning and a gong when you finish.  In Zoom you will get private messages from rGeoffrey about time.  Sounds may also happen though we are still working out the details.
• After you are accepted you will be invited into a Slack channel for lighting talk speakers (provided you have a Slack account) and that is where you can ask the rest of your questions or see the answers from those who asked before you.
• Traditionally advertisers just sit in the front row and speak during the time speakers are swaping laptops.  This year be in the Zoom room and chat to rGeoffrey either in Zoom or Slack and be ready to be called on between speakers.  The speakers will get their screen shared while you speak.

...

BOF stands for Birds of a Feather. These are informal get-togethers planned by attendees and can be on any topic, technical or not. Please see the wiki or #cic-hallway in Slack in order to plan or attend the meetings.

Anyone have any questions?

A gathering of all things Dancer

BOF stands for Birds of a Feather. These are informal get-togethers planned by attendees and can be on any topic, technical or not. Please see the wiki or #cic-hallway in Slack in order to plan or attend the meetings.

Submit a lightning talk

See the full description on the Day 1 version of lighting talks


The Schedule

--

Distributing a Perl module via Bioconda (Miniconda)
Andrea Telatin

Perl has a long history of serving the bioinformatics community, and nowadays "Miniconda" has become the most used package and dependency manager for bioinformaticians, with a very active channel called "BioConda". In this lighting talk I'll use BioConda as an example of bringing Perl tools (and modules) to Miniconda.

In spite of Miniconda being born in the Python world, 10% of all Bioconda packages are Perl modules, and several highly downloaded programs are written in Perl.

https://www.youtube.com/watch?v=zorouyVaGuE
https://raw.githubusercontent.com/telatin/learnperl/master/TPRCiC/bioconda_slides.pdf

--

Asynchronously Parallelish Testing In Raku
Vadim Belman

I needed this for Vikna, I implemented this. There were no escape and Test::Async came to be...

https://www.youtube.com/watch?v=gMjZ3nBcGWs
https://www.icloud.com/keynote/0s0hVNN1jd2viS-2_UvX5IUag#TPRCiC2020_Test-Async

--

MSYS2 and You
Zaki Mughal

Deploying Perl on Windows with certain native dependencies can be tricky. This talk shows how to use MSYS2 to access many of the same packages as on Unix-likes which opens up some interesting possibilities.

https://www.youtube.com/watch?v=s43DLnzoYeg
https://github.com/zmughal/talk-tpc20cic-msys2-lightning-talk

--

80% now, 20% never - Adventures in contentEditable
Max Maischein

A look at Carnet notes and how Perl can make editing them easier on the desktop

https://www.youtube.com/watch?v=Bh3q4tWUizc

--

The Perl Community Roadmap
Will 'the Chill' Braswell

Finally, the Perl interpreter has a strong technical roadmap through v7.0 and beyond! Now we can turn our attention to the larger questions of where our community is headed, and how can we become the masters of our own collective destiny? Let's figure out how to "Put Perl Back On Top"!

https://www.youtube.com/watch?v=xS6FseHf3lo
http://perlcommunity.org

--

Net::Matrix::Webhook
domm

Net::Matrix::Webhook implements a webhook, so you can easily post messages to your matrix chat rooms via HTTP requests. It uses IO::Async to start a web server and connect as a client to matrix. It will then forward your messages.

https://www.youtube.com/watch?v=Fby5i2sDHCY
https://metacpan.org/pod/Net::Matrix::Webhook

--

Quick Debugging in Vim
Tina Müller

Are you typing Data::Dumper->Dump (or similar code) manually to debug? There's help!

https://www.youtube.com/watch?v=J09TLkVKu9Y

--

A Year of Alien and Platypus
Graham Ollis

A number of new features have been added to the alternative toolchain duo of Alien and Platypus. I'd just like to cover them briefly so that developers are aware of them and can take advantage.

https://www.youtube.com/watch?v=r_ccLlvn6bw
https://perl5-ffi.github.io/talk-perlcic-2020-alien-platypus/


State of Pull Request Club
Kivanc Yazan

Pull Request Club took over CPAN Pull Request Challenge at 2019. Come see how many people signed up, got assignments and contributed to open source. Also see how to join the club.

https://www.youtube.com/watch?v=bDFRqYfD-24
https://kyzn.org/slides

As compilers like gcc and clang advance, they probe deeper for weaknesses in source code, generating additional build-time warnings.  These enable Perl 5 contributors to write more accurate and portable code.  In this talk we discuss tools we have written in the past year to identify such warnings.

Slides: http://thenceforward.net/perl/tpc/CiC-2020/slides/
Tarball of slides: http://thenceforward.net/perl/tpc/CiC-2020/build-time-warnings.tgz
Text of talk: http://thenceforward.net/perl/tpc/CiC-2020/further-adventures-in-qa.pdf

Most intros to Docker only show overly simplified Dockerfiles.

In this talk I will show various ways you can improve Dockerfiles to generate better (smaller) containers. I will use Net::Matrix::Webhook as an example, showing some ways bring container size down to 25% of what a “default” Dockerfile would produce.
Slides: https://domm.plix.at/talks/writing_a_good_dockerfile_for_perl_app.html

While some years ago you could only do very basic YAML stuff in Perl, that has changed!

Over the last years, a lot of improvements have been made to the Perl YAML Ecosystem, also thanks to The Perl Foundation and the Perl Toolchain Summit.

Bugs in existing YAML modules have been fixed (syntax parsing errors, memory leaks, etc.), secure loading of untrusted input has been made possible.

With YAML::PP a module has entered CPAN which is one of the first three projects that was written by using the cross-language yaml-test-suite.

It aims to be as powerful as PyYAML. Successful tools like Ansible are using PyYAML. Although Ansible just uses a small part of what’s possible in PyYAML, it couldn’t have been written in Perl. I want to make that possible.

I’ll show you what kind of cool stuff you can do with YAML::PP already!

You should already be familiar with the basic YAML syntax.

Slides: https://perlpunk.github.io/slides.2020.tpc20cic/

Tutorial: https://www.yaml.info

Your fantastic application is online and it started attracting users. Suddenly, you realise you need to change the schema of the data. How to do it properly for both the running system and possible future deployments? How to do it without crashing the running application?

If we imagine a database powering our application, each schema change comes in two forms: one is the actual ALTER TABLE, the other one is the updated CREATE TABLE that will be used in future deployments. Blindly applying the former might break the application for users that are using it at the moment of the change. If your application is more complex, it might have several components with their own schemas. How can we change the user without breaking the whole application? Perl will be used in the examples, but the findings are valid in general.

Slides: https://e-choroba.eu/20-updates

The Perl Foundation are here to support the Perl and Raku communities.

Members of the board will update you on our plans and initiatives, and then it is your opportunity to share your ideas, concerns and to ask us questions.

Following introductions and a TPF update, attendees will have the opportunity to ask questions.

We are collecting questions in advance at https://github.com/tpf/cic-panel-2020/issues. Please make a new issue or upvote an existing one. We will also take questions that come in during the session.

Unlike many (maybe most) free software projects where the same people write the code and the documentation for it, it was a design decision from the beginning that documentation of Raku, its classes and more meta stuff, would be clearly separated from the interpreter (and the rest of the parts of Raku) itself. A documentation repository was created by Moritz Lenz, who started to hammer away at writing down what every piece of Raku did, and how to put together programs and modules that use it. This documentation repository eventually became host to three different things: the source of the documentation itself, written in Pod6, a SLANG within Raku for documentation, but also the command that indexes and shows that documentation, a series of modules that process and extract metadata and source from that documentation to generate a static website.

The management of the site became a do-ocracy, with anyone with a commit bit deciding on where to go next, which issues to address, which PRs to accept, in a model that is actually not so different from the rest of the Raku ecosystem, but which makes sustainable and, over all, long term development, a challenge. In this talk we will first analyze the model of Raku documentation and what kind of lessons can be learned from it for software development at large, and Perl and Raku development in particular. Then we will analyze data on contributions to the Raku documentation repository and see how this software development model has worked out, what it lacks and what can be done to improve it just a tiny bit.

In 2019, everything (kind of) changed. A student, Antonio Gámiz, worked on a new system to parse, index and generate the documentation called Documentable. This was intended as a plug-in replacement for the former doc-site generation script, but it’s eventually something that’s a bit more than that. It creates a stack of modules that are not monolithic, have many endpoints for use, and can become a new ecosystem for document processing. This is still very much a work in progress, but it’s reduced by 75% the time needed to generate the whole documentation, and almost by 90% the time needed to regenerate it.

This talk is, at the same time, an presentation of the documentation as an entryway for the community, a overview of Raku design, and a technical talk on how to create a good (maybe not excellent) documentation processing and rendering system.

I am going to present a fully static parser for Perl or a Good Enough subset of Perl.

It doesn't need runtime. It doesn't use regex. It doesn't use PPI. It doesn't require any custom code.

As raku matures, we need useful basic eco-system modules to bring the unique strengths and cultural style of raku to the wider world. Imagine a universal library of extensible raku classes spanning the sciences - Physics, Chemistry, Bio-sciences, Economics, Maths, Ecology, Virology. For this vision to be possible, one core tool is a standard module to represent real world measurements of values and units.

Physics::Unit and its sister Physics::Measure, combine the unique capabilities of raku to build on the popularity of this perl5 module in a newly released raku native rewrite. This talk is in two parts (i) highlighting the usefulness of raku’s unique combination of capabilities - Grammars, Unicode, Rats, infix/postfix operators, Types, OO - all had a place in the implementation and (ii) showcasing how these modules can be used as a natural extension for scientists or engineers at any skill level.

Unlike any other Units module, raku makes it possible to apply Units for the full range of use cases - source code examples and demonstrations will cover embedded postfix units, unit conversion, unit math, unit / object geometry in Jupyter notebooks. With support for US, Imperial and SI units covering base units, derived units and user defined units and parsing.

https://www.slideshare.net/daoswald/perl-setting-up-an-internal-darkpan

As the world moves toward lightweight microservices we are often faced with the dilemma of pulling a large shared-code repository into our containers (rendering them anything but lightweight), or copying in shared libraries (losing the benefits of upstream progress), or …. setting up a Darkpan. With a Darkpan it is easy to convert a repository of shared modules into independent distributions that can be pulled down by containers as they build using typical CPAN tooling such as cpanm and Carton in conjunction with Docker.
I’ve had to do just this, recently, and implemented my work both using a Jenkins pipeline, and with a Stash/Bitbucket to Docker to OpenShift process. In this discussion we will explore the why and how of setting up a Darkpan.

I plan to bring modern OO to the Perl core. I’ve been stealing ideas from Stevan Little, Damian Conway, and anyone else foolish enough to leave their ideas lying around. This talk is about Cor: my modern OO proposal. Sawyer’s expressed interest and it's likely it will go into the Perl core.

I’m not going to beat around the bush: writing object-oriented code in Perl is a shambolic mess. Some people want to use bless and hand-roll everything, others insist upon using Moo/se, while still others others reach for Class::Std, Spiffy, Class::Tiny, some in-house monstrosity their company uses and so on. You have to relearn it again and again and again.
In this talk I’ll explain Cor, an attempt to design a modern OO system for the Per core. Currently the syntax still feels like Perl, but it fixes many problems with existing systems and will leapfrog the capabilities of OO systems in many other languages.

Continuous Integration systems such as GitHub Actions and CircleCI allow you to automate tasks such as building, testing and linting your code. After this talk you’ll be equipped to use these tools to:

• Build and test your code on Linux, macOS and Windows using GitHub Actions and CircleCI
• Speed up your build time
• Set up code coverage
• Use build artifacts

I will be using some Perl-specific examples, but much of the content will be useful across different languages.  This talk will get you up and running quickly and will provide you with sample configurations you can use right now. In particular, we will talk about lightning fast testing for Dist::Zilla modules, installing your Perl prerequisites faster and a strategy to build once and then test many times.

Slides at https://github.com/oalders/presentations/blob/master/slides/4-github-actions/marp.pdf

See also https://github.com/Perl/docker-perl-tester

Raku provides a variety of mechanisms for graceful threaded processing. Queues are nice, handle all of the bookkeeping, and have a fair bit of overhead. Lazy gathers require a bit more planning but can be quite a bit faster with race() or hyper() to make them happen. This talk looks at examples of each, describing the syntax for using them and showing the performance tradeoffs and some ways to benchmark them in your own environment.

I wanted a quicker way to figure out the loot that monsters had. That also turned out to be a good reason to learn how to use a module and understand YAML a bit more.
Once I was able to quickly get loot, what about determining what the kinds of things the players met? It was an ideal excuse to write a dispatch table. Once I had that written I wanted to share it. Instead of trying to figure out how to package it up, I learned how to use the Mojolicious web framework to make it a web app.
Form fillable PDFs make it easy to provide pre-generated characters for players at a gaming convention. What if I could start with a simple YAML file and have a program fill out the PDF for me?
Much of my hobby code I’ve written is to support one of my favorite hobbies, RPGs.
After attending this talk I hope that you will better understand how to:

• use a module to randomly generate events
• use a dispatch table instead of nested if structures
• share a program you wrote that goes from the command line to the web.
• use your hobbies to improve your skills in other areas of your life
• sharing your work with a community makes you aware of how you code

Slides available at: https://archive.org/details/using-rpgs-to-fuel-my-code-habit

I spend most of my terminal time in bash and vim, so little slowdowns in either disproportionately drain my time and energy. Since mid-2019, I have smoothed over warts in those tools by creating new shortcuts and by learning more about what the software already offers! Users of any Unix-like environment will find something they can use in this collection of bash, git, vim, and command-line tips. Attendees will learn new ways to decrease their frustration and increase their productivity. -Ofun!

There are already great IDEs for both Perl (Padre) and Raku (Comma).
They're both designed to help you write software faster
...by providing a range of syntax-based coding tools.
More importantly, they can both help you rewrite software better
...by supplying a set of language-aware refactoring mechanisms.

There's only one problem: neither of them is Vim
(or Emacs or «your editor-of-addiction here»).

In this talk I'll introduce a new set of modules, designed to
make it easy to add syntax-driven Perl source refactoring
and other useful code transformations to any modern text editor,
or any other scriptable application.

Along the way, we'll explore the horrors of Perl's scoping rules,
navigate the labyrinth of Perl's many argument passing conventions,
and descend briefly into the whirling maelstrom that is
generalized semiautonomous contextual API inference.

We'll also look ahead to examine how I'm planning to implement
the same set of code manipulation tools for Raku, and see why
that's going to be at least two or three times as challenging
...but also an order of magnitude easier.

BOF stands for Birds of a Feather. These are informal get-togethers planned by attendees and can be on any topic, technical or not. Please see the wiki or #cic-hallway in Slack in order to plan or attend the meetings.

BOF stands for Birds of a Feather. These are informal get-togethers planned by attendees and can be on any topic, technical or not. Please see the wiki or #cic-hallway in Slack in order to plan or attend the meetings.

BOF stands for Birds of a Feather. These are informal get-togethers planned by attendees and can be on any topic, technical or not. Please see the wiki or #cic-hallway in Slack in order to plan or attend the meetings.

We will use a zoom room please ask to be sent there when you join zoom

Come talk about Mojolicious

By the time this description is being written the new project named Vikna is still in deep development status. Though most of the critical components are already in place and more to come in the next months. The project is an experiment in creating a UI toolkit written in Raku from ground up. If succeed it will be the first complete terminal UI toolkit for Raku providing easy way for developers to equip their applications with interactive communication to a user.

Internally, Vikna designed to utilize the most advanced Raku language features with focus on being as much parallelized as possible. Yet, life teaches us the importance of the balance and that too much of parallelization might fight back and harm in many possible ways. But when used properly it pays with performance and extra freedom for user code. Say, some code prints diagnostics info while working. Usually one uses print, or say to send it to the console. But what if the code is multithreaded or otherwise asynchronous? How to sort out the mess of interleaving lines coming from different threads? With Vikna one could have one widget per each thread and use it like:

$widget.say: "Hello world!";
And that’s all!

… Ok, ok! Yes, there should be some boilerplate for starting the application. But basically it winds down to something like:

class MyApp is Vikna::App {
has Channel:D $.connection-queue .= new;
method main {
...; # Your application preparation code
start react {
whenever $.connection-queue -> $new-connection { self.start-processing: $new-connection }
}
}
method start_processing($conn) {
my $out = $.desktop.create-child: Vikna::TextScroll, ...;
$out.say: "Let's go!";
start { ...; } # do you work here
}
}

Does it look scary? :)

OpenTracing
Knowing
Is your system slow, or only under certain circumstances or with specific request? OpenTracing and ‘Distributed Tracing’ may be helpful to understand what is going on.

Join this presentation for 50 minutes and quickly gain back zillions of nanoseconds!

Introduction to OpenTracing
From the OpenTracing.IO website:

Distributed tracing, also called distributed request tracing, is a method used to profile and monitor applications, especially those built using a microservices architecture. Distributed tracing helps pinpoint where failures occur and what causes poor performance.

OpenTracing is comprised of an API specification, frameworks and libraries that have implemented the specification, and documentation for the project. OpenTracing allows developers to add instrumentation to their application code using APIs that do not lock them into any one particular product or vendor.

Perl5 and OpenTracing
With an increasing number of Framework Plugins and Integrations, it becomes more and more easy for Application Developers to add instrumentation to an existing (web) application.

These Plugins only have a limited responsibility: to bootstrap a OpenTracing compliant Implementation.

Integrations, on the one hand, need to be capable to extract (implementation specific) tracer information from in incoming request, or, on the other hand, inject that information into an outgoing request to a (micro) service and other sub-systems.

Being ‘open’ or agnostic about third party tracing software services, also means that for each of those there needs to be a specific Implementation.

Some Integration solutions are readily available, others will require more development.

The OpenTracing Perl5 SDK
To make your task as a developer more easy, there are various tools available, most important the OpenTracing Interface POD. And as long as you keep your development stick to those API specifications, life is good. But there are Types and Test to help building compliant Integrations and Implementations.

PR’s are welcome!

This talk is about sharing techniques used by implementation of Concurrent::PChannel module. As the name suggests, the module implements a channel object for organizing data passing between different components of the same application including concurrently running threads. What makes the module different from the core Channel is support for prioritization of items sent over it. In other words, if two items are being sent simultaneously the one with higher priority will most likely be pulled out first even if in fact it was submitted second.
I was facing two challenges in module implementation. First, it must depend as little as possible on the number of priorities used by an application. Second, it had to be fast. Ideally, as fast as the core Channel. The first challenge wasn’t that hard to accomplish. But the implementation used lock protection around the most performance-critical parts of the code resulting in certain degradation under heavily-concurrent item submissions. And so I went onto the hunt for a solution which wouldn’t use locking.
The result? My benchmarks show median loss of 20-30% of performance compared to the core Channel. Is it much? I’d say it’s definitely not considering that the benchmark is run over 1000 different priorities! Think of it as of managing 1000 individual queues compared to a single one maintained by Channel. Moreover, it doesn’t really matter whether it’s 10, or 100, or 1000 priorities, the time it takes to send same number of items will always be the same.

Continuous Integration (CI) is the thing all the cool kids are doing. If you do some CI you will be cool too. You know you wanna! CI lets you ensure that every commit that goes to production was tested against your test suite (you do have a test suite, right?). There are a lot of products for CI, both on premise and SaaS.

Azure Pipelines is one of those SaaS products. The free offering for open source projects allows you to run ten jobs (that’s a lot!) in parallel on Linux, macOS, and Windows. It also lets you run on bare metal or in Docker containers. It supports all sorts of powerful features like multi-stage builds, dependencies, output caching, and more.

We’ll talk about many of those features, using my ci-perl-helpers project for context. I may even do a live demo if I’m feeling foolish. (Spoiler: I often feel foolish.)

You’ll come away with a general understanding of how you might bring CI back to your own projects, whether they’re open source or for your day job (or both), as well as learn how to use my helpers project to test your Perl distributions.

Online slides

Classic content management systems are centralized. Even if we speak about the cloud services or the systems with replicated databases — does not matter, data and its processing applications/services are hosted on particular server or pool of servers (providers). If you want to make such system decentralized, you will face the technically complex, time-consuming and expensive task with no any guarantees. But on other hand, in centralized system your provider can falsify data: modify it a little, grant open access (compromise data), spoof or delete. Of course, we do not talk about purposeful falsification: emergency (fire at data centre), hacker attack, mass virus or smth. Nevertheless, you can identify full data loss (or a half, 1/10, etc…), but what’s about small tweak or tamper?! Most likely you will operate falsified data as a trusted one.

If you use decentralized content management systems you avoid collisions considered above: data is stored on definitely interpreted, encrypted ledger within distributed network. Blocks can be decrypted with private keys. Each network member has own private key. As at example above, if hacker get private key on one host and falsify data, corrupted data will store in chain and you can (simply or not) identify what data is trusted/corrupted with comparisons or deep data analysis. Chain contains all data changes with timestamps, so if you identify abnormal activity in your server logs — just mark chain segment as potentially falsified. Moreover, if there is no trust in the provider, then nodes with read-only data access can be launched on its servers, i.e. servers will be used as data backup storage.

The Ethereum blockchain platform performs the necessary and sufficient set of utilities and tools for creating decentralized applications that can be used to store and manage tamper-proof data. Ethereum supports private (Proof-of-Authority) networks, features a smart contract functionality, has a mature ecosystem and well-structured documentation, propagates a quick start and, of course, is FOSS.

Within this talk we will discuss the methods and features of implementation secure decentralized content management systems on Ethereum blockchain with Raku Raku language (formerly known as Perl 6).

The practical part of this talk contains a short research in Raku tools for general programming of decentralized web applications. We will consider hybrid data storage model, the ways to reduce application response latency, implementation of both decentralized top-level applications and smart contracts providing low-level access to the blockchain. At the end we will demonstrate the prototype of CMS Pheix — an open decentralized Raku driven system in a public beta version.

This talk primarily aimed at software architects and developers of tamper-proof data systems, as well as Raku enthusiasts who are involved in blockchain technology and decentralization issues.

We’ve been moving towards separating our monoliths into microservices, being able to monitor those in a way that’s simple enough to do, but powerful enough to actually be useful is a difficult problem. We are solving it by having each service be able to tell us how it’s feeling by writing diagnostic that tells us whether a part is working correctly. Having a standard for the HealthCheck Diagostic Result format means that we can even implement it in our Go services or those written in any other language.

You’ll learn about the idea behind HealthChecks, plus some of the Diagnostic’s we’ve open sourced and how we’re not only using it to make sure individual instances are healthy enough to be serving requests, but also how we’re finding other ways to use it to increase visibility into how the service is performing.

Writing software to be used by people in different cultures can be a lot of work, with lots of extra boiler plate in many different languages. But things don’t have to be that difficult or messy. Come to find about the new Raku modules that can make internationalization a painless process. Leave knowing how to work with language tags, localization frameworks, special tokens for regexen, and Unicode’s CLDR in a way that is both fully standards-compliant and 100% Raku-ish.

95% of all debugging is print statements, but once or twice a year, a problem shows up that is best attached with perl5db.pl, the venerable core Perl 5 debugger. Like a light saber, it dates back to a forgotten time and its operations are poorly understood. Unlike a light saber, it is not elegant, and nobody aspires to use it. Also, it can cut limbs right off. Still, it’s a very useful multi-purpose tool, and if you learn how to use it, it can save a lot of time and clear up a lot of mysteries.

This talk will cover what the debugger is, how to use it at a basic and intermediate level, how to customize it, and at least one or two stories about how it is very, very awful.

Both Perl and Raku have great strengths and we have more to do so that this can be shared with others outside our community.

During the preparations for FOSDEM, we created banners and messaging to support the great work done before. These were very well received at FOSDEM and we had a great deal of positive feedback however they were created in a hurry and a more strategic process is required.

By having messages and brand assets to hand, it will become easier to put together high quality and professional material to present around Perl and Raku.

People looking to learn a language or go back to something they have used before will be more comfortable if they feel that the brand is strong and matches that of other languages and technologies. It is important for organisations setting out on a project to select appropriate technology and for sponsors to have comfort that Perl is still relevant. Perl and Raku are not suitable for every situation so getting this right will help show where they could be the best solution and equally when they are not.

This is a TPF supported activity, please come along and share your thoughts and ideas - and you don’t need to know marketing to add value. Here are some of the ways you can provide input:

• tell us what you like about other digital tech brands
• what has worked for Perl in the past, what has not
• have you created content, flyers and other material - come and share it
• what are the strengths and weaknesses of both Perl and Raku compared to other competitive languages
• why did you choose Perl / Raku?

I hope that we can maintain the conversation after the event and work together to sustain the ongoing activities.

Picking up a second, third… etc. programming language is always easier because you have a reference to a language you already know. But language tutorials are rarely made assuming one language, and worse yet most PowerShell intros are for non-programmers. This talk would be a great opportunity for efficient learning(visualize that scene in the Matrix where Neo wakes up and says “I know Kung-Fu” I will step through all the necessary info one would need to start programming in PowerShell in about 40 minutes. I plan to open with 5 minutes on background and advertising why one might want to consider PowerShell, and end with a list of resources and a take away cheatsheet and Q&A.

This talk covers the basics of USB control packets, how to capture USB packets for inspection, and how to send usb messages in your programs. Examples given in Raku.

LibYear is a dependency freshness measure which helps you learn how out of date your project’s dependencies are. While LibYear has considerable value when used as a “spot” metric, something that you just measure once, there is even more power that can be unlocked when you observe how the metric has trended over time. In this talk, we’ll explore a tool, libmetrics, which is able to compute this metric across a project’s history. The libmetrics tool supports many different dependency management tools from many different frameworks. Also during this talk, we’re going to look at graphs of LibYear over time for many different open source projects. By analyzing these graphs, we can see the long term impacts of different decisions, such as when a team decides to start using Dependabot.

Raku already invites the programmer to participate in compile time, for example by implementing trait handlers, customizing meta-classes, producing meta-objects in an EXPORT, or using BEGIN blocks directly. These are utilized by a range of modules, such as Red (an ORM), Cro (used for building web applications) and ASN::META (parsing an ASN specification and exporting Raku classes based on the specification).

The key limitation today is that there’s no document object model for Raku code itself. For example, it would be desirable in a web framework to have a Raku regex used for validation on the server side be translated into one usable on the HTML5 pattern attribute - however that would only be achieved today by a program choosing to re-parse the Raku regex syntax itself! Similarly, modules that produce Raku code and EVAL it would be far more robust if they could instead build a tree of objects representing the Raku program. Macros, too, will only reach their potential if the programmer can work with the AST passed in.

Therefore, I’m currently working on RakuAST, a user-facing Abstract Syntax Tree for Raku programs. In this talk, I’ll share the design and implementation progress on that so far, and some of the things it will enable.

Submit a lightning talk

See the full description on the Day 1 version of lighting talks

The Schedule

--

Whim: A Webmention multitool for the command line
Jason McIntosh

Whim is a brand-new command-line tool (written with Mojo!) that lets you receive, process, display, and send webmentions from the command line.

Webmention is a recent, W3C-approved technology that aims to promote the proliferation of independent websites through a simple protocol of open, cross-domain notifications.

I have been obsessed with this technology for the past two years, and I will try to explain why, sharing a lot of resources for further study.

https://www.youtube.com/watch?v=J2VLrZ9nh2E
https://jmac.org/whim/tpc2020/

--

Vala: my new favorite leaky abstraction
Chris White (CXW)

The Vala programming language is a better C than C... until it's not.

https://www.youtube.com/watch?v=6kZSusnIVwI
https://github.com/cxw42/cxw42.github.io/blob/master/presentations/cxw-tprcic-2020-lightning.pdf

--

Perl on Lambda
Jesse Thompson

I will show how you can run Perl functions natively on AWS Lambda

https://www.youtube.com/watch?v=cbbDjo4ZT4k
https://docs.google.com/presentation/d/1ENmA_ENKfmpS_RKokEjH2t9iCOZb9K6xQQJbkMhJjmU/edit?usp=drivesdk

--

Sub signatures - do we still need them?
Ilya Chesnokov

I've been using sub signatures for a couple of years already - and quite enjoyed them - but...

https://www.youtube.com/watch?v=hTjA77Fz37o

--

A quest for automation: Testing operating system builds
Santiago Zarate

At openSUSE (and SUSE Software Solutions) we deliver operating system images, a lot of testing

https://www.youtube.com/watch?v=WlBO9xndBwQ
https://github.com/foursixnine/stunning-octo-chainsaw/blob/master/openQA/perlconference-openqa.pdf

--

Control a remote machine from your mobile, with Telegram!
Andrea Telatin

Telegram can provide an interesting interface to talk to your scripts in a remote machine that just needs an Internet connection. WWW::Telegram::BotAPI will help!

https://www.youtube.com/watch?v=Nhtmy7BI3-w
https://github.com/telatin/TPC2020/raw/master/tprcic-telegram-telatin.pdf

--

Random Drum Fills!
Gene Boggs

Combine MIDI::Drummer::Tiny with Music::Duration::Partitions to create random, but in-time, drum fills!

https://www.youtube.com/watch?v=_fNSw2R-LnM
https://www.ology.net/dev/drumfills/

BOF stands for Birds of a Feather. These are informal get-togethers planned by attendees and can be on any topic, technical or not. Please see the wiki or #cic-hallway in Slack in order to plan or attend the meetings.

Just a BOF session for people interested in talking about the Rust language.

A few interesting details about Rust:

• The design of Rust is focused on safety and zero-cost abstractions.
• Rust has strong support for concurrency and thread safety.
• Rust is designed to guarantee memory safety, so there's no need to worry about buffer overflows, dangling pointers, freeing memory twice, null    pointers or data races.
• Go can detect data races (maybe), but Rust is supposed to be able to actually prevent them in the first place.
• Rust offers automatic memory management without garbage collection or reference counting, but optional reference counting is available.
• Rust compiles to machine code with performance comparable to C++.
• Variables and references are immutable by default, but easy to make mutable.as well.
• Advanced type system with "traits" with OO programming capabilities with static type checking, inheritance, polymorphism, roles and mix-ins.
• Lambda functions are also supported.
• Rust requires no runtime support code and can even be used to implement an operating system on bare metal.

See https://tpc20cic.sched.com/tickets for purchasing information

There are a few million new languages making buzz on the Internet these days, and Go is one of them! Go hits a nice sweet spot between ease of coding, speed of execution, and modern features such as type inferencing, concurrency, and a minimalist but well-designed OO system.
In this class, I’ll introduce you to Go basics including syntax, the type system, OO in Go, packages and package management, and concurrency.

This is a hands-on course. Each lecture section is followed by a hands-on exercise section where you put what you’ve just learned into practice. The instructor will work with each student individually as needed to help you get the most from these exercises.

This class is aimed at anyone who wants to learn Go. You must have experience programming in at least one other language, but no assumptions are made about what language that is, nor are you expected to be familiar with Go.

Students are expected to bring a laptop with the most recent version of Go installed and an editor of their choice. You will also be expected to follow the instructions in the class’s git repository in order to obtain a copy of the class slides and exercises.

Here are what some past students of this class have said:

• “Dave’s Intro to Go class got me up and running with Go quickly. The many exercises throughout the day helped the material sink in.” – John Thompson
• “The class was engaging with a series of sections: learning a new concept, coding the concept and validating the code against pre-written tests.” – Anonymous Student