We are doing this time for the second time. Let's give you some impressions. We have a really nice venue with the Center for Art and Media in Karlsruhe. Last year, we had great talks about how the universe and the structure and everything fits together. We had keynotes from Matthew Rocklin. So I just want you to invite to come to Karlsruhe, talk to us.

We are the organizers. There are many more organizers here. And one small announcement. We have the first keynote speaker confirmed. So Wes McKinney will be in Germany. So if you ever want to rant about pandas or ask him some questions why the indexing works like it works, this is your chance.

So see you in Germany. Thank you Peter. Oh, you're ready to go? Okay, I'll let you go. All right. Thank you. So I'm Niklas. I'm the chair for Python Ireland.

And we organize a yearly conference about Python to PyCon. So this year will be the 10th and 11th of November. Lots of hashtags, email, links, so you can find me around. We're looking for more speakers, of course. Sponsorship is still available.

And extra news about Ireland and Python. We have 40 pilot schools starting Python in high school now, and there will be a first sitting exam in Python for Leaving Cert in 2020. So that's something interesting. So if you have experience in teaching computer science

and want to help that, you know, set up properly in Ireland, come to me as well. I'll be around all week. Thank you. Thank you very much. Yes. So hi, I'm Raden Doprowski and I'm going to try to convince you that Zen of Python

is actually harmful for the Python community and Python programming. So, yeah, the reason why I'm here is, you know, Zen is the Japanese philosophical thing. There is a competition to that called Tao, which is Chinese. And one of the translations of one

of the parts of Tao is when the way is forgotten, duty and justice appear. Then knowledge and wisdom are born and along with hypocrisy. And the thing is, you know, what actually is Zen of Python? So it was an e-mail posted by Tim Petters

on the Python developers mailing list quite a bit ago. There wasn't Python 3 yet. And it was actually a summary of some rules of thumb that he observed being used when deciding whether to put something into Python or not and how to design it.

And it was humorous. It was actually a joke. Unfortunately, not everybody got it. So it got added to Python as an Easter egg. You can actually type import this to get it displayed. And it is actually used sometimes, not that often, but as a weapon

to, you know, cut discussion and say, OK, this is against Zen of Python, we won't have it. Or, you know, a part of it is gets quoted as an argument against something, which is very strange because the way it is structured, why it's called Zen is

because every other sentence is a negation of the previous one. So you can pretty much say anything you want with this. Anyway, so here are some examples of how the Python developers themselves don't actually follow it.

So first, it's simple, it's better than complex. And that's obviously excellent advice. So recently there was a new implementation of a dict in Python that is obviously much better than the previous one. It uses less memory, it's faster. However, it makes the dict sorted.

And because of that, the definition of Python as a language is, was changed to include that into dict that dicts are sorted. And one of the features of complexity is that you entwine the implementation with the definition with your API.

And in this case, that's actually damaged a little bit the MicroPython, which doesn't, can't use this particular implementation because of memory needs. And now it has a problem because MicroPython's dicts are not sorted and will not be. So it's not Python anymore. Explicit is better than implicit.

You know this super call that everybody complained about. In Python 3, that has been shortened to implicitly take all the arguments that it needs from your local scope. And yeah, that breaks this advice, obviously.

Flat is better than nested. But recently in Python 3, we see a lot more use of the with statement. It gets into the standard library a lot. We've seen it in the keynote today morning. It's getting used a lot. And what it does, it lets you do your custom nested things in Python.

Errors should never pass silently. So the recently fixed, actually, this is a fixed bug, so kudos to that. OS list, they would silently ignore all files it couldn't convert to Unicode in your local file system without raising any errors. Yeah, there should be one and preferably only one obvious way to do it.

So we have now three or four ways of formatting strings in Python. Admittedly, each next one is better than the previous, but you still have to learn all three to understand code.

Yay! Namespaces are one honking great idea. This is the last point. And actually, I'm shocked because there was no namespace added to Python since that was published. And it says, let's do more of those. Even things like the type annotations

with like beg for a separate namespace, you don't want to use the same names for types, for type annotations as you have in your code, because you don't use them in your code anywhere. You don't need them in the same namespace. No, they are in the global namespace. So, yeah,

the thing is, once things are written down, you forget about them. You get them out of your head on top of the paper and they become dogma. And you can only use them as, you know, love advocates and as a weapon. But what's important is the process that actually produces, produced those rules.

We can reuse the same process again to produce new rules when the situation changes. And this way, the language and the community will be alive. So don't be, you know, like a language lawyer. Don't be a Zen of Python lawyer.

Don't follow the rules strictly. Just think about what, how they were actually came up to. How they were produced and... OK, Rademir, thank you very much. A big round of applause, please, Rademir.

Hi, my name is Sebastian, and I would like to talk with you about keyboards. Those beautiful creatures that are so perfectly designed that after hours and hours of using them every day, they leave us with nothing less but the feeling of ultimate satisfaction, right? Well, except that they are not perfectly designed.

But it actually took me a couple of years to notice it. I remember when I first discovered that some people are swapping the escape key and caps lock, and I thought, wow, it's actually amazing. I mean, when you think about it, the capsule keys, one of the biggest keys out there, and you only really use it when you need to argue with someone on Facebook.

While the escape key, use it way more often, even if you're not a VM programmer, but it's way smaller and it's quite inconveniently located. So I swapped those two together and I was very happy until I got this guy. So apparently Apple decided that you won't be able to swap

the escape key from the touch bar with any other key. So I was stuck with two escape keys, one on the touch bar, one on the caps lock, and no caps lock key, which was bad. I mean, what if someone is wrong on the Internet? How can I keep my discussions to a typical Internet level if I cannot turn on the caps lock? So I had to find a solution, and I did a bit of reading.

And I found something that is, I think, the most clever solution I have seen in my life. You see, someone came up with an idea to map pressing both shift keys at the same time to activating caps lock. So you press both shift keys, you activate the caps lock, you press both shift keys again, you deactivate it. Again, once I saw it, I thought, this is brilliant.

And it works not only with the MacBooks, it works with any keyboard, and it's a really nice trick. So that made me think about productivity. Like, are there any other ways that I can improve the way I work? So I did a bit of reading, and I found this Getting Things Done book by David Allen. It was mentioned on many websites related with productivity. It had a lot of reviews, so I thought, it has to be good.

It wasn't. I mean, the book is OK, but it talks mostly about creating lists. And if you have been working for a while, you probably already figure out that making lists of things that you have to do will help you. So I was a bit disappointed. And I tried to find other ways. And what I found is that what really works well

for me are all small tips that I can start using right away, not like whole methodologies that will require me to change the way I work. But those tips are not easy to find. I mean, people don't write books about productivity tips. People write books about methodologies. And sometimes you don't even know that something is possible, so you don't try to improve it.

Like, I didn't know that you can actually remap keys on your keyboard. So I'm going to share with you a couple of things that I found, and maybe some of you will find it useful. Most of you probably already heard about the dot files. Like, if not, then you should really check them out. Those are basically like configuration files for your computers. So you can store them on GitHub and you can download them

on each new machine that you will be using. And that way you will immediately have all your settings or your comments or your shortcuts back. I'll actually have a link to the slides so we can check the source. Don't take pictures. And the same applies to Veeam. You can configure all your shortcuts or your plugins or your mappings by editing just one file.

And it also applies to Git. I mean, you can define some one or two letter shortcuts for the most common commands that you're using, but you can actually write some more advanced functions. Like, I have a function that will squash together last and commits, or I have a different function that will check out the pull request from GitHub to a separate branch so I can view the code there. And there is no way I would remember how to do this

from the top of my head without checking StackOverflow. But once you put it in this Git config, it's super easy to use. Coming back to Veeam for a moment, I don't use Veeam very often, but I found a very useful tip. Use the spacebar as a leader key. It's much bigger. It's centrally located. You can reach it with both hands. So it's going to be way easier to use than default backslash.

And one thing that I notice is that each time I log into IPython, the production machines to do some debugging, I always have to use, I quite often use the same commands and that requires me to type from full import bar each time. So that's annoying. And apparently there is a way to configure IPython.

So each time you start it, it will execute some arbitrary code. So this is pretty nice. And speaking of typing the same stuff over and over again, there are some phrases that you probably type quite often, like your full name, your home address, your email or whatever, your signature of your email. And so you can use a text expander that will take like a small block of text and expand it to predefined sentences.

So it's basically like code snippets in real life. So here are just a few of my productivity tips. And I know that there is a lot of people here who have their own shortcuts, their own mappings, their own settings that make their life much easier. So I would really love to talk with you guys. So if you can find me, I will be here until Friday.

Or if you can't find me, just ping me on Twitter and the slides with the links to those files are available there. Thank you. OK. Thanks very much, Sebastian. Round of applause. Are you ready to go? OK, go. Hello, everyone. So I'm Tony. I'm going to talk about Point Break. So I don't know why I'm doing my life, but I seem to

spend an awful lot of time in GDB and other debuggers. I found that using a debugger is, especially with a complicated program, is a tedious process. Using a debugger manually, quite often I'll get to the point I want to debug and then I'll do the wrong thing and then I have to redo it all. Particularly when you're debugging a complicated program,

something unexpected might happen and again, you have to redo everything. It's really annoying. And also, quite often I want to not necessarily directly debug something, but monitor something or investigate something in my program, like maybe log something or just use something like a debugger to find out what's going on. So this is Point Break.

It was a film. The tagline was 100% adrenaline. So my tagline is 100% pure Python. This is what we have at the moment. If you want to extend your debugging with something that's scriptable, so you have something like GDB, which is a command line debugger, with a Python interface in there and an API that lets you write code.

But it's all embedded in the debugger and you have to use their API. What I would like instead is like a debugger that's just a library in Python that I can write programs against, because then I can build other tools on top of that. So if I had a debugging library, I could build an analyzer that used the debugger to collect information, any UI to present it to myself or someone else.

So what we have at the moment, I think it's OK. But I think that my idea would be way more awesome. So you could do something like you could write a simple program that just looked at, put breakpoints on two methods to collect some information, then like graph the number of things. So this is like create foo, destroy foo. Then you've got a number of, account of that, the calls, total number of foo's that exist any one time.

Or you could create something really complicated with like, you know, crazy logic and like reactive breakpoints and investing in all kinds of stuff that would tell you exactly what you've done wrong. That might be too hard, but it's a possibility. So it's a simple demo. OK, right. With the power of GNOME Shell. So here's a really simple C program.

It doesn't do anything other than call a function 10 times in a loop. It doesn't print anything. There shouldn't be any output. So if I make that, then I run it. Unsurprisingly, it does nothing. Then this is a... How do I make things small? That one.

So this is a little script written against Point Break, my debugger. So I add a breakpoint, which is just a Python function. It's going to print boo each time it hits that C function, there is a ghost. So if we run that, it prints boo 10 times. Dead simple.

So it's really early days. I spent about two weeks developing this. At the moment, it's Linux 64-bit only. API is still developing. It doesn't yet read dwarf symbols, which will be really useful because that will give you line debugging information and other

information about types. The reason it doesn't do that is the parser is too slow. So I'm working on that. It's missing many common debugging features. But yeah, so I'll probably be sticking around for the sprints and maybe working on this. But if you like the idea or you hate the idea, come and say hello. Thank you very much.

Big round of applause for Andy, please. What to do with a flock of lambdas? Library and talk by Andy Fundinger. That's me. There's my email. I'm a senior engineer at Bloomberg. I'll get one thing out of the way right off the top.

What is flock good for? Usually that's a question at the end. Right at the beginning, it's fun. It's kind of in effect like a spreadsheet. It's good for dealing with poorly defined mathematical systems like, say, taxes or role playing games. And I'm really looking for more uses out of this. So if you find something that you think this

would be useful for, tell me after. I'd really like to know. So let's just look at some fairly normal functions. There's a function. There's a function declared with the lambda. There's the lambda declared with no arguments. Hey, look, it does what you expect. Here's some closures. There's a perfectly normal closure with a list inside it.

It also does what you'd expect. If we change the list, even though it's already inside a closure, it's going to return based on the list that's already enclosed. Even though we edited the list, that's just a reminder that that does what it's supposed to do.

Enough of that. Let's take a look at dictionaries. We're going to make some closures. We're going to put them in the same dictionary that's inside the closure. That's inside that they're inside of. They're all references. So we can totally do this. Let's just pretend we're putting up a bill of sale.

So we'll put 30 of something. These are all zero argument lambdas. Price 100. The subtotal is going to be the quantity times the price. Call each of them as we pull them out. We'll take the New York City sales tax, put that on,

calculate the tax, calculate the subtotal. And then if we call each of those and pull it out, we're just evaluating closures and we're getting the values. All of this just calls the things inside, pulls it out and gets it evaluated.

The tax line, we can just pull out the tax line. Now, we're in Edinburgh. So let's say we're just going to say the tax here is seven percent. That's a little more complicated. So we change just the tax rate to seven percent. And we just want to see the tax and we just want to see the total.

We don't have to go back and do everything else. We can just pull out these two values. And that's really what we've been going for here. So it's a neat trick. If we clean this up, let's hit three things to clean it up.

Soaring a constant should not require creating these constant lambdas. We know any time we pull it out, we want to call it. And we may want to do some caching eventually. So we'll prepare for that. So now it looks like this. We can just put values in. We create a flock dict out of the flock library. And when we put a constant in, it notices and deals with that.

We still create our lambdas just the same way. But we don't have to say we're going to call it flock knows when we pull it out that we're going to be calling it to pull out the value. And our subtotals all work out the same way that functionality is preserved.

But we're here so we can add some more tricks because we know what we're doing. So I've created something called an aggregator. We'll make our bill of sale, have five different items on it, each with its own quantity, each with its own price. Then I can create a flock aggregator. Say I'm going to have some parallel

maps and here's the properties to go across them. Again, we'll calculate those when they're needed. And here's a function in this case, a to argue in this case, taking a tuple of the things going in that will calculate across it. I can go ahead and see what's the price on line three.

I can go ahead and change the price each on line three and then just go look at the total line. And it just comes dropping right out the bottom of the function. Now, if I have a flock, I should be able to share my flock.

So sharing the flock just removes all this special functionality and gives me kind of a final answer for every value of every lambda in the entire thing, calculates it out like this. So here we see the prices, the price, each is the quantities, the subtotals, the taxes, the tax rates, the total. Everything dropped out once I shared my flock.

It's up on my GitHub. There's my email. There's the corporate Twitter. And as I said, what's it good for? I'm really looking for the question of what is this good for? It's fun.

And let me know. So, hello, my name is Lior and I'm from Israel. And when I'm working in a startup and when we started to be large, we decided about security rules, right? One of the security rules is you have to lock your computer every time that you

go to coffee or something. Now, for me, two things happened. One, I always forgot it. And the second thing, all of my friends knew that they always forgot it and started to look and start to hack my computer when I'm not near it.

How many people it happened for them? Cool. So it's not just Israeli thing. So I tried to think, what can I do? And the best idea that I came with is I have a Bluetooth in my phone. If I'm leaving, I can check it.

So I tried to think if there is something like this for Mac users, there is something like 10 applications, that is what they are doing. For Windows, there is a Windows feature for that. In Windows, it's weird.

For Mac, there is this application, but it's old. And for me personally, it didn't work. So I started to look and found this blog that explains how you can, without pinging, check what is your connection.

OK, and we just write it. This is a script, best script from the blog that is doing that. OK, and if I will run it, you'll see that it's trying to connect. RSI is the connection. OK, so if I'm not near my computer, right?

And then on top of that, we created a small Python script that check it. Every time that it's less than minus one, it's added to a queue.

And check the queue, OK? So if I run it, and go with my telephone to drink coffee or something, two issues.

Thank you. Two issues. One issue is if your office is narrow

and with multiple places that you can go, maybe your computer suddenly will get up and down, up and down when you're not in your room. And the second thing is now all my friends are trying to steal my telephone.

Thank you. OK, over to you. OK, so hi, I'm Thomas, and this talk is about something I noticed for many years. It's not about Python, even if it looks like, but you'll see.

So I guess most of you know the docstrings, dunderdoc, they are pronounced, so not underscore, underscore, doc, underscore, underscore, just say dunder, that means the same. And you all know you can use them to interactively get help or to generate documentation using Sphinx or some other toolkit.

And you can also access it from the code. So the code basically knows about its documentation. And this is how you do it. You just have a class and a docstring in there. And if you are on the interactive Python interpreter, you can just use the help function to access that kind of documentation.

So you don't need a browser. You can just use the Python interpreter. And why do we do this? Because so we don't have to wonder about what is this class doing. We document our stuff and everybody can use it that way. So the class self documents itself.

So this was the technical part of my talk. And now to something different, we also have some sort of documentation issue in real life. So a lot of you hang around on conferences like this one.

Maybe some of you also visit the hackerspace or in general, just the place with a lot of people. And if there are a thousand people like here, you maybe don't know a lot of them, maybe most of them. But all of them are maybe working on some interesting project,

but you don't know it. And why do you not know it? Because there is no documentation. It looks like this, for example, you see just a lot of people doing things on their laptops. But you don't know what. More people doing things, but you don't know either.

So everybody's doing something, but you don't know what. So, OK, you can just go to them and say, hey, what are you doing? But maybe you are shy, maybe you don't want to do that. And even if you would do that, it does not scale.

I can't walk to a thousand people and say, hey, what are you doing? It's just taking a lot of time. So we can use docstrings. So the idea is just document yourself. And if a lot of people do that, they can just read other people's docstrings, basically.

So you can use just a piece of paper but in that case, you need to prepare it. Just print a few of your projects on it in big letters so you can read it from two metres distance, at least. And if it's not totally clear what it means,

maybe add some explanation below it in a bit smaller font. Some nice graphics is also nice. And don't write too much, only a few words. You don't want to take an hour to read it. So put on the paper what interests you, what you love, what you work on, maybe what you did work on in the past.

You can use a piece of paper. You can also use your laptop screen, but that's a bit problematic if you want to work on it at the same time. You can use a beamer with a second screen and just beam it somewhere, a projector, I mean. You can use a poster or you can just use a T-shirt

and write something about Python on it. But it's not great for Python conference because everybody does Python, of course. And this is an example how it could look like. So left the example, right the explanation, maybe just put your name on it, the projects you love, a short line under it explaining what it is, some keywords,

maybe add some colour over your home page or whatever. And then just put it besides you. If you are sitting somewhere and hacking on your laptop, just put it besides you so people can just read it. They don't need to say hello to a thousand people.

And then you have a doc string, basically. You can use these slides for whatever you want. You know this license? Do what the fuck you want. Public license, it basically says do what the fuck you want. So, yeah, distributed.

Thank you very much for coming. I guess we kick off at 9 a.m. tomorrow. Yeah, OK. Bye, everybody.