Reuven Lerner: Upcoming Python/Pandas courses for seasoned coders

Planet Python - Sun, 2022-10-23 09:22

Python and Pandas can improve your career. I say this all the time, partly because it’s my job (as a Python/Pandas trainer), and partly because I’ve seen how people’s lives and careers can improve with this knowledge.

But what if you’re already familiar with Python and Pandas?

The good news (and bad news, for that matter) is that there’s always something new to learn. I’ve been using Python for 30 years, and literally every day I discover something new about the language. And Pandas? It’s such a massive library that I’m no longer surprised to be learning new functionality and techniques.

A few weeks ago, I asked subscribers to my “Better developers” newsletter to tell me what topics they most want to learn. I’ve tallied the results, and am delighted to share the first batch of live courses that I’ll be offering over the next week.

It’s no surprise that people asked for courses that are aimed at intermediate- and advanced-level coders, who are familiar with the basics and want to take things to the next level.

Like all of my courses, these will be done with live coding in Jupyter, lots of hands-on exercises with real-world data, and plenty of opportunities to ask questions.

  • Design patterns in Python: What are design patterns, and how can we implement some of the best-known patterns into Python? This four-hour live course, on Sunday October 30th, will teach you what you need to start understanding, and using, design patterns right away.
  • Intro regular expressions: Many people find regular expressions scary, which is why it’s so appropriate that I’ll be introducing them on Halloween (i.e., October 31st). We’ll talk about metacharacters, repetitions, and character classes, and see how Python lets us search for patterns of text.
  • Advanced regular expressions. If you’re already familiar with the basics, then let’s make things more interesting for you — with grouping, capturing, lookahead/lookbehind, and other techniques that’ll solve even the toughest text-searching problems. This four-hour class will take place on November 1st.
  • Dates and times in Pandas: I’ve met many people who understand how to work with numbers and text in Pandas, but had no idea it was so powerful and versatile when working with dates and times. In this four-hour class on November 6th, we’ll look at dates and times in Pandas from a variety of perspectives. Don’t miss out on one of the coolest, and least known, areas of Pandas functionality.
  • Applying functions in Pandas. Pandas comes with a huge number of built-in methods that can do amazing things with your data. But sometimes (often?) you need to do something unusual and different — and in such cases, you can apply a function to your series or data frame. In this two-hour class on November 7th, we’ll explore how to apply functions, when we would want to do it, and what facilities Pandas provides.

Questions? Just e-mail me at reuven@lerner.co.il. Questions go straight to my inbox, and I’ll respond ASAP.

I look forward to seeing you in these courses!

The post Upcoming Python/Pandas courses for seasoned coders appeared first on Reuven Lerner.

Categories: FLOSS Project Planets

Kirigami Addons 0.5 release

Planet KDE - Sun, 2022-10-23 07:40

Just a small note that Kirigami Addons 0.5 was released yesterday. This update only contains some small cleanups here and there (e.g. moving some implementation details from the public api to the private one).

The package is available on download.kde.org and was signed with my new GPG key

Categories: FLOSS Project Planets

IslandT: wxPython Tutorial — Create Dialog Box

Planet Python - Sun, 2022-10-23 04:54

In this wxPython example tutorial, I will write the program to call a function which will then create a dialog box after a button has been clicked.

First of all, from the previous program, I have to add the below line under the CreateButton function which will call another function after the button has been clicked.

self.the_button.Bind(wx.EVT_BUTTON, self.OnButton)

The reason I have created the function separately instead of putting all the commands under one single function is that I want to reuse the OnButton function again in future code.

def OnButton(self, event): self.CreateDialogBox()

As you can see once the button has been clicked the OnButton function will get called based on the button’s Bind method.

def CreateDialogBox(self): self.dialogbox = wx.Dialog(parent=self.the_frame, id=5, title="Hello Enter", name="Hello") self.dialogbox.Show()

At last, the above method has been called and the dialog box appears after the show method has been called!

According to the wxPython official site, the dialog widget has the below parameters but I am not going to use all of them.

Parameters parent (wx.Window) – Can be None, a frame or another dialog box. id (wx.WindowID) – An identifier for the dialog. A value of -1 is taken to mean a default. title (string) – The title of the dialog. pos (wx.Point) – The dialog position. The value DefaultPosition indicates a default position, chosen by either the windowing system or wxWidgets, depending on platform. size (wx.Size) – The dialog size. The value DefaultSize indicates a default size, chosen by either the windowing system or wxWidgets, depending on platform. style (long) – The window style. name (string) – Used to associate a name with the window, allowing the application user to set Motif resource values for individual dialog boxes.

The outcome is as follows:-

There are other things you can do with this dialog box thus please don’t hesitate to try it out!

Categories: FLOSS Project Planets

Marcos Dione: blender-hillshading-and-mapnik

Planet Python - Sat, 2022-10-22 18:43

How did it start? Well, it actually started a long time ago, maybe a year ago, most probably more. I got myself tumbling down the beautiful rabbit hole of Blender based mapping. The idea is very simple: if you have a DEM, you can build a 3D representation of the terrain and use a renderer to build your map. To me the most striking thing about those maps were not their 3D-ness (which to some it's starting to be tiresome , and I agree), but the shadows. I've been pursuing the best shadow for a while, and this seemed like the perfect fit.

So, like I said, one year ago or so I took "the" Blender relief tutorial and run with it. I got to the point where I could reproduce it with a 1x1, 3600x3600px DEM from mapzen, but when I tried to automate it, I found out that Blender has a python console where it prints out the commands that are equivalent to the actions you make in the UI, but the resulting script was too horrible to my eyes and run out of breath (another of those cases of the perfect being the enemy of the good).

Then a few days ago I read that first link and got some steam build up. In fact, it was two passages in it that lit up the fire:

Most of these use a tool called Blender, an extremely powerful open-source tool for all kinds of 3D modeling and rendering. A few cartographers use other tools, such as Aerialod, or R‘s Rayshader plugin.

R! I can easily automate this!

If we stick to a very zoomed-out map, or if we have a really huge computer running Blender, we could try to do a hillshade for the entire world, and then slice that up for our map tiles. But there’s no way we could do this at a high-enough resolution so you could zoom all the way in, as in the sample tiles above.

Challenge accepted! (Spoiler: I'm not there yet).

I tried Rayshader. I wanna be honest: it's easy, quick, but I didn't like the results. It seemed like no matter how high you put the sun, it always drew very long shadows. So despite its pragmaticism, I left it on a side.

So I picked up what I did in the past and tried to apply it to a map. I re-rendered everything and applied it to my style. The outcome was encouraging:

To start with, I probably did that render with not enough render passes, so the output looks grainy. Second, the material color is too bright, so the height tints are washed out. Still, we can see the big shadow cast over the valley some 3200m below the Mont Blanc/Monte Bianco.

This proved to be a good place to test the method, because of the great difference between the valley and the peak casting the shadow over it, and that lead me to think: are there more extreme places in the world? An easy bet is yes, and the place to look for them was the Himalayas. The Aconcagua could have been a good contender, but the valley at its SE is some 4550m already. Surprisingly, the way I searched for a good place was to use existing maps with the usual hill shade technique, looking for big dark spots, specially those wide in the NW-SE direction. I first found my spot in the Tukuche Peak, that looms some 4350m above the Gandaki River, and then the nearby Dhaulagiri, that's even some 1250m higher, clocking at 8167m. Here's how they look (not the big structure in the upper left, but the bigger grey [8000m+] blob to the East of it; the river snakes in the right all the way down):

I had to add 3 more color bands to my style and reshuffle them because I never rendered any 8k'er before, so the colors were haphazardly concocted for the rendering and are not definitive. At least it lets you behold the grandiosity of that rock jutting through thousands and thousands of meters with very steep sides.

Time to get real. I usually render regions were I'll be going, and next time it's the Upper Segre Valley, so I rendered N42E001-2 in one go. That's 7201x4884px after reprojecting to WebMercator (and compensating as described in the second link!), so some 35Mpx. Blender took some 44m+ on a 4.5yo medium-high spec'ed laptop at 200 render samples, which means that I can continue to render small regions this way, but that for the moment I won't be applying this technique to the whole Europe.

Up to here I was just applying the same style in QGIS, which has been an indispensable tool to develop this style. But trying these TIFFs in mapnik for the first time needed an extra step. Well, two, in fact. Blender does not save the TIFFs georeferenced, so you have to copy the data from the original DEM. For that, use gdal_edit.py -a_srs ... -a_ullr ... with the right ESPG and the data from the output of gdalinfo. Next, for some reson, it always use 16bits integers, even when explicitly saying to use 8. This little snippet takes care of that:

import imageio image = imageio.imread(&apospirinoak-blender-10x.tif&apos) image = image / 256 image = image.astype(&aposuint8&apos) imageio.imwrite(&apospirinoak-blender-10x-8bits.tif&apos, image)

Thank $DEITY (and developers!) for good libraries.

The first thing I noticed was that we have been lied by maps (again!) for a long time. Most hill shading algos use a 45° high sun (the direction does not matter much). But if you think about it, how many mountains have sides 45°+ steep? According to a (real, not like me!) cartographer friend, for continental Argentina it's less than 1% at 30arcsecs of resolution (note that SRTM is 1arcsec). Still, some shadows are there, and they help us (and we get used to that) to recognize slope direction. And now we're asking a raytracing program to calculate real shadows? The result I initially got was underwhelming, even when I was already asking Blender to exaggerate height by 5x!:

So, I bit the bullet and went all in with 10x:

Much better, but not definitive. I still have to render Dhaulagiri again, and at least some region I already know well by having being there a lot.

Now some notes about "the" Blender relief tutorial. I followed it to the letter, but with my experience I had to make some changes. One you already know, using a displacement scale of 10x instead of 0.3. I have no exact idea why his initial rendering were so spiky, but I suspect that the DEM grid unit was not meters.

Second, since that first Mount Blanc/Monte Bianco render, we know the color is too bright. I lowered it to 0.6 (and later I found that that's what he actually suggests at the end of the plane section) and then compared the grey in a plain (#b5b5b5) to what GDAL outputs and compensated using a simple coefficient. The final value is 0.402.

Third, I was having issues rendering: I was getting a lot of terracing. After a long chat with Viktor_smg from blender.chat/support they figured out that the sRGB color space in the Image Texture is broken and that I should use XYZ instead. This meant installing Blender by hand instead of relying on the one in Debian Unstable because it's too old and does not have it. They also gave me pointers about how to automate it.

Last, you can't apply this technique DEM by DEM because you want the shadows from the neighbouring tiles to spill over the current one. That link shows how to render the tile and its 8 neighbouring ones, but I think that you can optimize it in two ways: First, since shadows come from the NW, just add the tiles that lie in that general direction. Second, no shadow would cast over 10s of kilometers. You could even get away with just adding a smaller band around the tile.

That's it for now. The next step is to automate this an publish that. $DEITY knows when that will happen.

python openstreetmap gdal elevation hillshading imageio gis dem

Categories: FLOSS Project Planets

parallel @ Savannah: GNU Parallel 20221022 ('Nord Stream') released

GNU Planet! - Sat, 2022-10-22 15:13

GNU Parallel 20221022 ('Nord Stream') has been released. It is available for download at: lbry://@GnuParallel:4

Quote of the month:

  If used properly, #gnuparallel actually enables time travel.
    -- Dr. James Wasmuth @jdwasmuth@twitter

New in this release:

  • --latest-line chops line length at terminal width.
  • Determine max command length faster on Microsoft Windows.
  • Bug fixes and man page updates.

News about GNU Parallel:

GNU Parallel - For people who live life in the parallel lane.

If you like GNU Parallel record a video testimonial: Say who you are, what you use GNU Parallel for, how it helps you, and what you like most about it. Include a command that uses GNU Parallel if you feel like it.

About GNU Parallel

GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.

If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.

GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.

For example you can run this to convert all jpeg files into png and gif files and have a progress bar:

  parallel --bar convert {1} {1.}.{2} ::: *.jpg ::: png gif

Or you can generate big, medium, and small thumbnails of all jpeg files in sub dirs:

  find . -name '*.jpg' |
    parallel convert -geometry {2} {1} {1//}/thumb{2}_{1/} :::: - ::: 50 100 200

You can find more about GNU Parallel at: http://www.gnu.org/s/parallel/

You can install GNU Parallel in just 10 seconds with:

    $ (wget -O - pi.dk/3 || lynx -source pi.dk/3 || curl pi.dk/3/ || \
       fetch -o - http://pi.dk/3 ) > install.sh
    $ sha1sum install.sh | grep 883c667e01eed62f975ad28b6d50e22a
    12345678 883c667e 01eed62f 975ad28b 6d50e22a
    $ md5sum install.sh | grep cc21b4c943fd03e93ae1ae49e28573c0
    cc21b4c9 43fd03e9 3ae1ae49 e28573c0
    $ sha512sum install.sh | grep ec113b49a54e705f86d51e784ebced224fdff3f52
    79945d9d 250b42a4 2067bb00 99da012e c113b49a 54e705f8 6d51e784 ebced224
    fdff3f52 ca588d64 e75f6033 61bd543f d631f592 2f87ceb2 ab034149 6df84a35
    $ bash install.sh

Watch the intro video on http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.

When using programs that use GNU Parallel to process data for publication please cite:

O. Tange (2018): GNU Parallel 2018, March 2018, https://doi.org/10.5281/zenodo.1146014.

If you like GNU Parallel:

  • Give a demo at your local user group/team/colleagues
  • Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
  • Get the merchandise https://gnuparallel.threadless.com/designs/gnu-parallel
  • Request or write a review for your favourite blog or magazine
  • Request or build a package for your favourite distribution (if it is not already there)
  • Invite me for your next conference

If you use programs that use GNU Parallel for research:

  • Please cite GNU Parallel in you publications (use --citation)

If GNU Parallel saves you money:


GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.

The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.

When using GNU SQL for a publication please cite:

O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.

About GNU Niceload

GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.

Categories: FLOSS Project Planets

EuroPython Society: List of EPS Board Candidates for 2022/2023

Planet Python - Sat, 2022-10-22 13:10

List of EPS Board Candidates for 2022/2023

At this year’s EuroPython Society General Assembly (GA), planned for Saturday, 29 October at 17:00 CEST, we will vote in a new board of the EuroPython Society for the term 2022/2023.

List of Board Candidates

The EPS bylaws require one chair, one vice chair and 2 - 7 board members. The following candidates have stated their willingness to work on the EPS board. We are presenting them here (in alphabetical order by first name).

We will be updating this list in the days before the GA. Please send in any nominations or self-nominations to board@europython.eu.

Please note that our bylaws do not restrict nominations to people on this list. It is even possible to self-nominate or nominate other candidates at the GA itself. However, in the interest of giving members a better chance to review the candidate list, we’d like to encourage all nominations to be made before the GA.

The following fine folks have expressed their desire to run for the next EPS board elections: Alexander Hendorf, Anders Hammarquist, Artur Czepiel, Cheuk Ting Ho, Nicolás Demarchi, Patrick Arminio, Raquel Dou, Silvia Uberti, Theofanis Petkos, Vaibhav Srivastav, Vicky Twomey-Lee.

Alexander Hendorf

Pythonista / Consultant / Serial Organiser

Alexander joined the EPS spontaneously as auditor at EuroPython 2014 in Berlin when no one else felt like it. In the following five years he was an integral part of the EuroPython team, in particular as program chair,  and for two years as board member.

Alexander was elected 2nd chairman of the German Python Software Association (PySV) in 2018. In this role, he is responsible for the German conference PyConDE, which he has co-organized since 2016.

To support Open Source Software in academia he was invited to join EuroSciPy in 2018. The Pandas documentation sprint was a good reason to establish two local PyData chapters, PyData Südwest and PyData Frankfurt the same year. Both thrive with more than 1300 members today.

In 2018, Alexander was named a PSF Fellow by the Python Software Foundation for his contributions to the community. In 2021 he was named a EuroPython fellow.

Alexander is responsible for data and artificial intelligence at the boutique consultancy KÖNIGSWEG. Through his commitment as a speaker, he is a proven expert in the field of data intelligence. He has many years of experience in the practical application, introduction and communication of data and AI-driven strategies and decision-making processes. He is very grateful that everyone at his company, Königsweg, in which he is also a partner, is in support of so many community activities.

Alexander is convinced it&aposs time for EuroPython Society to take its mission to the next level - to act as a roof and institution of the European Python community - beyond the EuroPython conference. The EPS should become better at supporting local communities at a variety of levels in the future: e.g. diversity & outreach, organising community events, mentoring opportunities or infrastructure. With his candidacy, Alexander offers his expertise, experience and implementation power to make this a reality.

Anders Hammarquist

Pythonista / Consultant / Software architect

Anders is running his own Python consultancy business, AB Struse, since 2019 and is currently mostly involved with using Python in industrial automation. He has been using Python since 1995, and fosters its use in at least four companies.

He helped organize EuroPython 2004 and 2005, and has attended and given talks at several EuroPythons since then. He has handled the Swedish financials of the EuroPython Society since 2016 and has served as board member since 2017.

Artur Czepiel

Software developer

Artur started using Python around 2008, originally to implement backends for websites and later expanding to other areas.

He joined the EuroPython team after the conference in 2017, working initially on the website and support. He joined the board for the 2018/2019, and more recently, the 2021/2022 terms.

For the next term he would like to continue the infrastructure work started last year, and focus on improving how the Society works outside of the conference and its relationships with other organisations in Europe.

Cheuk Ting Ho

Pythonista / Developer Advocate / Data Scientist


After spending 5 years researching theoretical physics in Hong Kong, Cheuk has transferred her analytical and logical skills in natural science and built a career in data science. Cheuk has been a Data Scientist before builder her career in Developer Relations.

Cheuk constantly contributes to the community by giving learning workshops and organizing sprints for open source projects, at the same time contributing to open source projects. On top of speaking at conferences, Cheuk has joined the organizing team of EuroPython as a member of the programming workgroup since 2019 and was hosting the lightning talk from the same year since.

In 2021, Cheuk joined the EuroPython Society Board and became the Python Software Foundation fellow. Cheuk has been leading the Financial Aid team to provide accessible tickets and travel grant for people around the world to join EuroPython. Cheuk has also started a speaker mentorship program in 2021 and organize workshops for new speakers. In this year’s EuroPython, Cheuk brings mentored sprint to the conference and hopefully encourage diverse contributions to open source projects.


Believing in the benefit the society has with diversity and inclusion, Cheuk would like to continue bringing new faces to the society and keep connecting people in it. In the upcoming year, Cheuk would like to keep the financial aid program running, bringing new leadership for EuroPython and forging more connections with other Python communities - including local Python conferences and Pyladies communities around Europe and communities beyond Europe.

After visiting a few PyCons in Africa in the past, Cheuk would also like to strength the bond between Europe and Africa, by proposing new program to support Python conference organisers in Africa to attend EuroPython.

Cheuk would also like to start the speaker mentorship in early 2023 to start grooming the next generation of speakers for the community. This should be a continuous effort and not limited to the EuroPython conference. Mentees are encouraged to submit to various community events before EuroPython as well. Priority to join the program will be given to people in the underrepresented groups.

Nicolás Demarchi

Pythonista / Software Engineer

Nicolás is a self-taught software engineer working professionally for more than 15 years. After participating in some Linux User Groups and the Mozilla community, Nicolás joined the Python community around 2012, fell in love with it and never left. He is a founder and has been a board member of the Python Argentina NGO since 2016. In the PyAr community, he participated in several events and conferences as organizer and/or speaker, ranging from Python Days in various cities, PyCamp to the Python Argentina national conference, being a core organizer in the 2018 one in Buenos Aires (an open and free conference with ~1500 attendees). Since 2014 Nicolás has been maintaining the Python Argentina infrastructure that supports the mailing list, webpages, etc.  He was (still helping a bit) the host of the Buenos Aires Python Meetup. In June 2019, Nicolás moved to Amsterdam and he is currently living and working there.  A few months after the move, he joined the organization of the Python Amsterdam meetup and he is working with a small team to build the local community: py.amsterdam. He also joined the https://pycamp.es/ team trying to replicate the Pycamp Argentina experience in Europe. In 2020 he volunteered in the Media Workgroup of Europython 2020 online as a core organizer.
He joined the EPS board in 2021 and helped to organize Europython2021-online and Europython-2022 in Dublin. In Dublin his focus was particularly on the Operations team and the hybrid format of the conference.

He has also been named PSF Fellow in 2021.

I would like to continue in the EPS board because I think Europython is the event connecting all European communities and therefore the right place to invest my time on. After the 2022 conference I think I know the EPS much more and I would like to invest my time in the conference organization but also in improving our organization, lowering the burn-out risk and keeping volunteers engaged for a longer time.

Patrick Arminio

Developer Advocate / Python Italia Chair

Patrick started his journey with the Python community at PyCon Italia 2 in 2008. After many years of helping run PyCon Italia (and other conferences) as a volunteer he became the Chair of Python Italia in 2017.

He has also been nominated as a PSF Fellow for his contribution to conferences and also open source software.

He currently works as a Developer Advocate at Apollo GraphQL.

Raquel Dou

Linguist / Python enthusiast

Raquel first met Python in 2013, during her MSc in Evolution of Language and Cognition, where she used Python to model the evolution of a simple communication system over time. She operates a small business providing language and technical services, in which Python is one of her primary tools. In her previous life, her undergraduate dissertation in Spanish was about ACTA in Mexico and had an earlier MSc in anthropology specialising in human origins.

She first attended EuroPython when it took place at her doorstep (Edinburgh) in 2018, and was an onsite volunteer. Since then she remained closely engaged in the EPS, as well as the organisation and execution of the conferences. She has been serving on the EPS board since 2019, working closely with the brilliant teams which delivered the two EuroPython Online editions. In 2021-2022, she had the privilege of serving as chair of the EPS. She led the organisation, supporting the rest of the board and the newly reformed teams in society affairs and organising the EuroPython conference in Dublin & Online.

Throughout the past 4 years she has experienced warmth, openness, creativity and desire to do good in every aspect of her engagement with the Python community which she proudly serves. She firmly believes that it is precisely these qualities that create strong bonds between the diverse humans that make up the community. She would like to continue to foster and strengthen this culture, and help make EPS a space for developing and trying out new ideas. Going forward, she would like to listen and engage in dialogue with other European Python communities to explore ways to gather experience and contributions, and build a collective knowledge base of community organisation. For the EuroPython conference, she would like to support more effort in curating the programme to showcase a broader spectrum of what we do with Python, the state of art of Python development, using Python to make art, Python in education and research, to name a few.

Silvia Uberti

SRE / IT Consultant

She is a Site Reliability Engineer with a degree in Network Security, really passionate about technology, travelling and her piano.

She’s an advocate for women in STEM disciplines and supports inclusiveness of underrepresented people in tech communities.

She fell in love with Python and its warm community during PyCon Italia in 2014 and became a member of EuroPython Sponsor Workgroup in 2017.

She enjoys working in it a lot and wants to help more!

Theofanis Petkos

Software Engineer / Python enthusiast

Theofanis&apos first encounter with Python was in 2011 during his Computer Science studies. In 2017, after a few years working at  non tech jobs, he resigned and followed his dream to become a software engineer. Right now he lives in Spain and he is a part of a DevOps team working mainly with Python. Recently, he became a member of Python Canarias.

He first attended EuroPython in 2020, as a speaker. He was a volunteer for the next two years as a part of the Financial Aid (2021), Mentorship programme (2021, 2022) and the Ops team (2022).

He loves animal facts, and he has a better sense of humour under pressure!

Vaibhav Srivastav

ML Tinkerer & Consultant

Vaibhav (VB) is a Machine Learning Researcher and Consultant. He has been working with Python and adjacent scientific communities for over a decade. He is an open source enthusiast and thrives on building and running open source communities. Python has been an integral part of VB’s career and life. He started by organising Python meetups in Delhi in 2016. He then went on to volunteer for various PyCon across APAC (India, Philippines, Malaysia, South Korea, Singapore and Indonesia). At the peak of the pandemic, VB moved from India to Germany to pursue his masters and research speech and natural language processing at the University of Stuttgart. After a brief hiatus, he joined the EuroPython 2021 volunteering team to help with the Sponsors team. He renewed his commitment to EuroPython by volunteering for the communications and programme team for the year 2022.

Through each chapter of his volunteering journey, VB has been lucky to have gotten the opportunity to work with some truly exceptional people. He also is grateful to the EuroPython Society for giving him the autonomy to run comms related experiments throughout last year.

Should VB make it to the EuroPython Society 2023 board, he’ll spend his time and energy on rethinking the way the programme has worked in the past and tweak to fit the present needs of our community. He’d also like to focus on introducing more avenues of interaction for marginalised communities (especially neuro-diverse) to support each other and prosper under the EPS’s umbrella.

You can read more about his commitment and plans on https://vaibhav.wiki/running-for-europython-board.

Keep calm and keep eating spaghetti! (pipx run saghetti)

Vicky Twomey-Lee

Diversity in Tech Advocate / PyLadies Dublin

Vicky Twomey-Lee has been involved with the Python community since 2005 where she took over running monthly Python Ireland events until she handed over the reigns in 2016. She was chair of the first four PyCon Irelands from 2010 to 2013, where in 2013 she launched PyLadies Dublin which she currently still organise monthly meetups. She advocates diversity in tech through her other initiatives as co-founder of Coding Grace, a co-director Women Who Code Dublin, a member of Women in Technology and Science Ireland as well as collaborating with many community groups including Women in AI Ireland, international PyLadies chapters like PyLadies Paris, PyLadies Munich, and PyLadies London.

She was made a PSF Fellow in 2012, and was awarded the PSF Community Service Awards and EPS Fellow in 2021.

She previously was on the EPS board in 2012 to learn how to improve PyCon Ireland’s process in conference admin and logistics, and is delighted to be invited to be on the EPS board again. She will contribute her knowledge to the board from experiences she collected over the years of running events and being involved with specifically the Irish Tech Community. She’s also still learning about logistics and administration when it comes to community events, and being part of the EuroPython team in 2022 was quite an exhilarating experience. And she wants to encourage communities to be just as excited to get involved with EuroPython and help make it accessible for all.

Chair Nominations

Raquel Dou is running for the chair position again this year.

What does the EPS Board do ?

The EPS board is made up of up to 9 directors (including 1 chair and 1 vice chair); the board runs the day-to-day business of the EuroPython Society, including running the EuroPython conference series, and supports the community through various initiatives such as our grants programme. The board collectively takes up the fiscal and legal responsibility of the Society.

At the moment, running the annual EuroPython conference is a major task for the EPS. As such, the board members are expected to invest significant time and effort towards overseeing the smooth execution of the conference, ranging from venue selection, contract negotiations, and budgeting, to volunteer management. Every board member has the duty to support one or more EuroPython teams to facilitate decision-making and knowledge transfer.

In addition, the Society prioritises building a close relationship with local communities. Board members should not only be passionate about the Python community but have a high-level vision and plan for how the EPS could best serve the community.

Categories: FLOSS Project Planets

KDE's Google Summer of Code 2022 Projects: Final Report

Planet KDE - Sat, 2022-10-22 06:51

By Johnny Jazeix

Google Summer of Code (GSoC) is a global, online event that focuses on bringing new contributors into open source software development. Like every year, KDE applied and aimed to integrate more and more developers. In 2022, KDE's participation in GSoC covered nine projects to improve KDE, of which six were successfully completed.

Snehit Sah worked on adding Spaces Support to NeoChat. Spaces is a Matrix tool that allows you to discover new rooms by exploring areas, and is also a way to organize your rooms by categories. The code is still not merged to the main branch.

Spaces in NeoChat

Suhaas Joshi worked on permission management for Flatpak and Snap applications in Discover. This allows you to change the permissions granted to an application (e.g. file system, network, and so on) and also makes it easier to review them. The code is in two separate repositories, one for Flatpak applications which is ready to be used, and one for Snap applications which is still work in progress.

Basic permission for Flatpaks

This year we had two projects to improve digiKam. The first one is from Quoc Hung Tran who worked on a new plugin to process Optical Character Recognition (OCR). The code has been merged and allows you to extract text from images and store the output inside the EXIF data or within a separate file. The plugin is also used to organize scanned text images with contents.

The second project is from Phuoc Khanh LE who worked on improving the Image Quality Sorter algorithms. The code has already been merged into digiKam and improves sorting images by quality using multiple criteria, for example, noise, exposure and compression.

For GCompris, KDE's educational software suite, Samarth Raj worked on adding activities for for using the 10's complements to add numbers. The activity will be split into three activities. One was finished during GSoC, the other two are still work in progress.

GCompris activity mockup

Two students worked on the painting application Krita. Xu Che worked on adding pixel-perfect ellipses in Krita. The work is still in progress and, once it is done, it will be merged. This will allow pixel artists to use Krita effectively.

Pixel-perfect ovals for Krita

Meanwhile, Reinold Rojas worked on exporting Krita images to SVG. The project provides more options to share files with Inkscape, and will help create translatable images with text for Krita Manual without knowledge of Inkscape. The code is still work in progress.

GSoC has again provided our nine contributors the opportunity to exercise their programming skills in real-world projects, allowing them to improve not only their code, but also their communication skills. We would like to thank all the mentors without whom these opportunities would not have been possible. We would also like to extend our appreciation to all the coders who invested their energy and passion into these two months of coding.

Categories: FLOSS Project Planets

IslandT: wxPython Tutorial — Create Combo Box

Planet Python - Sat, 2022-10-22 06:44

In this wxPython tutorial let us create a daily combo box beside the hello world button. I will not be going to repeat the previous program again thus if you want to look at the entire program you can refer to it in my previous wxPython article.

The official page of the wxPython Combo Box widget has the below parameters but I am not going to use all of them.

Parameters parent (wx.Window) – Parent window. Must not be None. id (wx.WindowID) – Window identifier. The value wx.ID_ANY indicates a default value. value (string) – Initial selection string. An empty string indicates no selection. pos (wx.Point) – Window position. size (wx.Size) – Window size. If DefaultSize is specified then the window is sized appropriately. choices (list of strings) – An array of strings with which to initialize the control. style (long) – Window style. See wx.ComboBox. validator (wx.Validator) – Window validator. name (string) – Window name.

Here are the lines of python code (including function) to create the Combo Box widget:-

def CreateComboBox(self): # create combo box daily = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"] self.combo1 = wx.ComboBox(parent=self.the_frame, id=3, value="", pos=wx.Point(30, 150), size=wx.Size(width=100, height=100), choices=daily, style=0, name="week day")

You can then call the CreateWidgets function to create the daily combo box likes before.

Categories: FLOSS Project Planets

OSM Indoor Mapping Workshop Recap

Planet KDE - Sat, 2022-10-22 04:45

Last weekend I attended an OpenStreetMap workshop about indoor mapping hosted by the German Federal Agency for Cartography and Geodesy in Frankfurt. After having started to use OSM indoor data in 2020 for KDE Itinerary this was my first opportunity to actually meet other people working on that subject in person.

OSM Indoor Data in KDE Itinerary

Indoor data here refers to mapping information about the inside of a building, which compared to outdoor map data tends to have an even higher need on precision (centimeter-level rather than meter-level), and much more often involves a third dimension (the floor level). In KDE Itinerary we use this to display detailed maps for train stations and airports.

Parts of Frankfurt central station displayed in KDE Itineary.

The OSM data model for this has been designed under the assumption of having a single self-contained building. Large train stations can however cover several city blocks, overstretching this model quite bit. That’s one of the topics I hoped to get input on during the workshop, and it turns out we are indeed not the only ones running into that problem.

Another issue we encountered is modeling of underground structures. While many elements (say a train track) can exist on their own above ground, they only really make sense underground with a corresponding “cut-out” around them (say a tunnel).

Different use-cases, very similar challenges

Displaying train station maps is just one possible thing to do with OSM indoor data, many other use-cases were represented at the workshop as well.

While that is a very diverse set of perspectives, a lot of this is relevant for features we sooner or later want in KDE Itinerary as well. Positioning, routing and 2.5D or 3D views are on the wishlist for our train station maps, and accessibility is something we want to focus on more as KDE as a whole as well.

And in any case, pretty much everyone is facing the same challenges regarding data modelling, data quality, data level of detail, processing algorithms, you name it. It’s certainly extremely valuable to have a forum to exchange on those topics.


One and half a day workshop wasn’t even remotely enough to cover all topics, so there are now online meetings planned to continue the discussion, as well as another in-person meeting at the FOSSGISS conference in March in Berlin.

Categories: FLOSS Project Planets

Andy Wingo: the sticky mark-bit algorithm

GNU Planet! - Sat, 2022-10-22 04:42

Good day, hackfolk!

The Sticky Mark-Bit Algorithm

Also an intro to mark-sweep GC

7 Oct 2022 – Igalia

Andy Wingo

A funny post today; I gave an internal presentation at work recently describing the so-called "sticky mark bit" algorithm. I figured I might as well post it here, as a gift to you from your local garbage human.

Automatic Memory Management

“Don’t free, the system will do it for you”

Eliminate a class of bugs: use-after-free

Relative to bare malloc/free, qualitative performance improvements

  • cheap bump-pointer allocation
  • cheap reclamation/recycling
  • better locality

Continuum: bmalloc / tcmalloc grow towards GC

Before diving in though, we start with some broad context about automatic memory management. The term mostly means "garbage collection" these days, but really it describes a component of a system that provides fresh memory for new objects and automatically reclaims memory for objects that won't be needed in the program's future. This stands in contrast to manual memory management, which relies on the programmer to free their objects.

Of course, automatic memory management ensures some valuable system-wide properties, like lack of use-after-free vulnerabilities. But also by enlarging the scope of the memory management system to include full object lifetimes, we gain some potential speed benefits, for example eliminating any cost for free, in the case of e.g. a semi-space collector.

Automatic Memory Management

Two strategies to determine live object graph

  • Reference counting
  • Tracing

What to do if you trace

  • Mark, and then sweep or compact
  • Evacuate

Tracing O(n) in live object count

I should mention that reference counting is a form of automatic memory management. It's not enough on its own; unreachable cycles in the object reference graph have to be detected either by a heap tracer or broken by weak references.

It used to be that we GC nerds made fun of reference counting as being an expensive, half-assed solution that didn't work very well, but there have been some fundamental advances in the state of the art in the last 10 years or so.

But this talk is more about the other kind of memory management, which involves periodically tracing the graph of objects in the heap. Generally speaking, as you trace you can do one of two things: mark the object, simply setting a bit indicating that an object is live, or evacuate the object to some other location. If you mark, you may choose to then compact by sliding all objects down to lower addresses, squeezing out any holes, or you might sweep all holes into a free list for use by further allocations.

Mark-sweep GC (1/3) freelist := [] allocate(): if freelist is empty: collect() return freelist.pop() collect(): mark() sweep() if freelist is empty: abort

Concretely, let's look closer at mark-sweep. Let's assume for the moment that all objects are the same size. Allocation pops fresh objects off a freelist, and collects if there is none. Collection does a mark and then a sweep, aborting if sweeping yielded no free objects.

Mark-sweep GC (2/3) mark(): worklist := [] for ref in get_roots(): if mark_one(ref): worklist.add(ref) while worklist is not empty: for ref in trace(worklist.pop()): if mark_one(ref): worklist.add(ref) sweep(): for ref in heap: if marked(ref): unmark_one(ref) else freelist.add(ref)

Going a bit deeper, here we have some basic implementations of mark and sweep. Marking starts with the roots: edges from outside the automatically-managed heap indicating a set of initial live objects. You might get these by maintaining a stack of objects that are currently in use. Then it traces references from these roots to other objects, until there are no more references to trace. It will visit each live object exactly once, and so is O(n) in the number of live objects.

Sweeping requires the ability to iterate the heap. With the precondition here that collect is only ever called with an empty freelist, it will clear the mark bit from each live object it sees, and otherwise add newly-freed objects to the global freelist. Sweep is O(n) in total heap size, but some optimizations can amortize this cost.

Mark-sweep GC (3/3) marked := 1 get_tag(ref): return *(uintptr_t*)ref set_tag(ref, tag): *(uintptr_t*)ref = tag marked(ref): return (get_tag(ref) & 1) == marked mark_one(ref): if marked(ref): return false; set_tag(ref, (get_tag(ref) & ~1) | marked) return true unmark_one(ref): set_tag(ref, (get_tag(ref) ^ 1))

Finally, some details on how you might represent a mark bit. If a ref is a pointer, we could store the mark bit in the first word of the objects, as we do here. You can choose instead to store them in a side table, but it doesn't matter for today's example.


Freelist implementation crucial to allocation speed

Non-contiguous allocation suboptimal for locality

World is stopped during collect(): “GC pause”

mark O(n) in live data, sweep O(n) in total heap size

Touches a lot of memory

The salient point is that these O(n) operations happen when the world is stopped. This can be noticeable, even taking seconds for the largest heap sizes. It sure would be nice to have the benefits of GC, but with lower pause times.

Optimization: rotate mark bit flip(): marked ^= 1 collect(): flip() mark() sweep() if freelist is empty: abort unmark_one(ref): pass

Avoid touching mark bits for live data

Incidentally, before moving on, I should mention an optimization to mark bit representation: instead of clearing the mark bit for live objects during the sweep phase, we could just choose to flip our interpretation of what the mark bit means. This allows unmark_one to become a no-op.

Reducing pause time

Parallel tracing: parallelize mark. Clear improvement, but speedup depends on object graph shape (e.g. linked lists).

Concurrent tracing: mark while your program is running. Tricky, and not always a win (“Retrofitting Parallelism onto OCaml”, ICFP 2020).

Partial tracing: mark only a subgraph. Divide space into regions, record inter-region links, collect one region only. Overhead to keep track of inter-region edges.

Now, let's revisit the pause time question. What can we do about it? In general there are three strategies.

Generational GC

Partial tracing

Two spaces: nursery and oldgen

Allocations in nursery (usually)

Objects can be promoted/tenured from nursery to oldgen

Minor GC: just trace the nursery

Major GC: trace nursery and oldgen

“Objects tend to die young”

Overhead of old-to-new edges offset by less amortized time spent tracing

Today's talk is about partial tracing. The basic idea is that instead of tracing the whole graph, just trace a part of it, ideally a small part.

A simple and effective strategy for partitioning a heap into subgraphs is generational garbage collection. The idea is that objects tend to die young, and that therefore it can be profitable to focus attention on collecting objects that were allocated more recently. You therefore partition the heap graph into two parts, young and old, and you generally try to trace just the young generation.

The difficulty with partitioning the heap graph is that you need to maintain a set of inter-partition edges, and you do so by imposing overhead on the user program. But a generational partition minimizes this cost because you never have to collect just the old generation, so you don't need to remember new-to-old edges, and mutations of old objects are less common than new.

Generational GC

Usual implementation: semispace nursery and mark-compact oldgen

Tenuring via evacuation from nursery to oldgen

Excellent locality in nursery

Very cheap allocation (bump-pointer)

But... evacuation requires all incoming edges to an object to be updated to new location

Requires precise enumeration of all edges

Usually the generational partition is reflected in the address space: there is a nursery and it is in these pages and an oldgen in these other pages, and never the twain shall meet. To tenure an object is to actually move it from the nursery to the old generation. But moving objects requires that the collector be able to enumerate all incoming edges to that object, and then to have the collector update them, which can be a bit of a hassle.


No precise stack roots, neither in generated nor C++ code

Compare to V8’s Handle<> in C++, stack maps in generated code

Stack roots conservative: integers that happen to hold addresses of objects treated as object graph edges

(Cheaper implementation strategy, can eliminate some bugs)

Specifically in JavaScriptCore, the JavaScript engine of WebKit and the Safari browser, we have a problem. JavaScriptCore uses a technique known as "conservative root-finding": it just iterates over the words in a thread's stack to see if any of those words might reference an object on the heap. If they do, JSC conservatively assumes that it is indeed a reference, and keeps that object live.

Of course a given word on the stack could just be an integer which happens to be an object's address. In that case we would hold on to too much data, but that's not so terrible.

Conservative root-finding is again one of those things that GC nerds like to make fun of, but the pendulum seems to be swinging back its way; perhaps another article on that some other day.


Automatic memory management eliminates use-after-free...

...except when combined with manual memory management

Prevent type confusion due to reuse of memory for object of different shape

addrof/fakeobj primitives: phrack.org/issues/70/3.html

Type-segregated heaps

No evacuation: no generational GC?

The other thing about JSC is that it is constantly under attack by malicious web sites, and that any bug in it is a step towards hackers taking over your phone. Besides bugs inside JSC, there are bugs also in the objects exposed to JavaScript from the web UI. Although use-after-free bugs are impossible with a fully traceable object graph, references to and from DOM objects break this precondition.

In brief, there seems to be a decent case for trying to mitigate use-after-free bugs. Beyond the nuclear option of not freeing, one step we could take would be to avoid re-using memory between objects of different shapes. So you have a heap for objects with 3 fields, another objects with 4 fields, and so on.

But it would seem that this mitigation is at least somewhat incompatible with the usual strategy of generational collection, where we use a semi-space nursery. The nursery memory gets re-used all the time for all kinds of objects. So does that rule out generational collection?

Sticky mark bit algorithm collect(is_major=false): if is_major: flip() mark(is_major) sweep() if freelist is empty: if is_major: abort collect(true) mark(is_major): worklist := [] if not is_major: worklist += remembered_set remembered_set := [] ...

Turns out, you can generationally partition a mark-sweep heap.

The trick is that you just don't clear the mark bit when you start a minor collection (just the nursery). In that way all objects that were live at the previous collection are considered the old generation. Marking an object is tenuring, in-place.

There are just two tiny modifications to mark-sweep to implement sticky mark bit collection: one, flip the mark bit only on major collections; and two, include a remembered set in the roots for minor collections.

Sticky mark bit algorithm

Mark bit from previous trace “sticky”: avoid flip for minor collections

Consequence: old objects not traced, as they are already marked

Old-to-young edges: the “remembered set”

Write barrier

write_field(object, offset, value): remember(object) object[offset] = value

The remembered set is maintained by instrumenting each write that the program makes with a little call out to code from the garbage collector. This code is the write barrier, and here we use it to add to the set of objects that might reference new objects. There are many ways to implement this write barrier but that's a topic for another day.


Parallel GC: Multiple collector threads

Concurrent GC: mark runs while JS program running; “riptide”; interaction with write barriers

Generational GC: in-place, non-moving GC generational via sticky mark bit algorithm

Alan Demers, “Combining generational and conservative garbage collection: framework and implementations”, POPL ’90

So returning to JavaScriptCore and the general techniques for reducing pause times, I can summarize to note that it does them all. It traces both in parallel and concurrently, and it tries to trace just newly-allocated objects using the sticky mark bit algorithm.


A little-used algorithm

Motivation for JSC: conservative roots

Original motivation: conservative roots; write barrier enforced by OS-level page protections

Revived in “Sticky Immix”

Better than nothing, not quite as good as semi-space nursery

I find that people that are interested in generational GC go straight for the semispace nursery. There are some advantages to that approach: allocation is generally cheaper in a semispace than in a mark space, locality among new objects is better, locality after tenuring is better, and you have better access locality during a nursery collection.

But if for some reason you find yourself unable to enumerate all roots, you can still take advantage of generational collection via the sticky mark-bit algorithm. It's a simple change that improves performance, as long as you are able to insert write barriers on all heap object mutations.

The challenge with a sticky-mark-bit approach to generations is avoiding the O(n) sweep phase. There are a few strategies, but more on that another day perhaps.

And with that, presentation done. Until next time, happy hacking!

Categories: FLOSS Project Planets

This week in KDE: UI improvements abound

Planet KDE - Sat, 2022-10-22 00:42

A ton of UI improvements landed this week. If you can’t find something to like in this post, I’ll eat my hat!

New Features

System Settings’ Firewall page now supports IP address strings with netmasks (Daniel Vrátil, Plasma 5.27. Link)

User Interface Improvements

On the Information tab of Gwenview’s sidebar, you can now reduce the area taken up by the metadata and description section using a draggable splitter between it and the Image Information section that’s above it. The splitter remembers its position, too! (Corbin Schwimmbeck, Gwenview 22.12. Link)

Spectacle now remembers the last-chosen rectangular region area by default, even across app launches. This is configurable, of course (Bharadwaj Raju, Spectacle 22.12. Link)

Kate and KWrite’s welcome screen (which remains optional, and able to be permanently disabled using a checkbox right on the screen itself) now includes links to documentation (Eugene Popov, Kate and KWrite 22.12. Link):

In the Plasma Wayland session, opening Dolphin from the Disks & Devices popup now raises its existing window, if it was already open (Nicolas Fella, Dolphin 22.12 with Plasma 5.26.1. Link)

Dragging-and-dropping windows onto the Pager Widget now works a lot better, with less fiddliness (Niccolò Venerandi, Plasma 5.26.1. Link)

When using Plasma, the “Open file with app…” dialog now uses the XDG portal version for improved visual consistency and user-friendliness. The old dialog is still used when you invoke “Open this file in a different app” functionality from a KDE app that’s not being used in Plasma (Harald Sitter, Plasma 5.27. Link):

System Tray Widgets that can be middle-clicked to toggle something about them on or off now indicate as such in their tooltips (me: Nate Graham, Plasma 5.27. Link 1, link 2, and link 3):

In the Plasma Wayland session, Help Center is now able to raise its open window when activated by another app (Nicolas Fella, Help Center 5.27. Link)

The icon size popup in System Settings has gotten a UI overhaul to remove unused settings and make what it does do more comprehensible (me: Nate Graham, Plasma 5.27. Link):

When you resize the Plasma calendar popup, text in the calendar itself now scales up and down appropriately (Fushan Wen, Plasma 5.27. Link):

The Overview, Present Windows, and Desktop Grid effects now try harder to pack windows efficiently, so hopefully you won’t see windows arranged like staircases anymore (Vlad Zahorodnii, Plasma 5.27. Link)

When viewing the page for a Flatpak app that has been marked as “end-of-life” by its developer, Discover now shows you the reason given by the developer (Aleix Pol Gonzalez, Plasma 5.27. Link)

Shadows behind the clock and date text on the login and lock screens are now a bit softer and prettier (Bharadwaj Raju, Plasma 5.27. Link):

The Lock Keys Widget now shows a different icon from the Keyboard Layout Widget, so can distinguish between them at a glance (Bharadwaj Raju, Plasma 5.27. Link):

In the Plasma Wayland session, the “Something is recording your screen” System Tray icon now uses a more correct “recording”-style icon (me: Nate Graham, Plasma 5.27. Link):

Trying to trash an item that’s bigger than the current trash size now gives you the option to delete it immediately if you want (Ahmad Samir, Dolphin 22.12 with Frameworks 5.100. Link):

Avatar images throughout KDE software are now sharper and better-looking when using a high DPI screen and screen scaling (Fushan Wen, Frameworks 5.100. Link)

Recent Documents lists throughout KDE software will now display appropriate icons for the recent files (Eric Armbruster, Frameworks 5.100. Link)

Significant Bugfixes

(This is a curated list of e.g. HI and VHI priority bugs, Wayland showstoppers, major regressions, etc.)

Fixed another cause of desktop widgets slightly moving around on login, which apparently has multiple causes (Aaron Rainbolt, Plasma 5.24.8. Link)

Fixed an issue that could cause input to not be detected when using the new mouse button rebinding feature (David Redondo, Plasma 5.26.2 with Frameworks 5.100. Link)

Plasma no longer constantly consumes high CPU resources when using an animated AVIF image as your wallpaper (Fushan Wen, Frameworks 5.100. Link)

Plasma no longer constantly consumes high CPU resources when disabling middle-click paste and copying certain content (David Edmundson, Frameworks 5.100. Link)

Other bug-related information of interest:

Automation & Systematization

This goal now has a Matrix room! Search for kde-institutional-memory:kde.org in your favorite Matrix client, or click here to access it in the web client.

The goal also has a team on https://invent.kde.org! You can join at https://invent.kde.org/groups/teams/automation/-/group_members. We’ll be using this for long-term task coordination via the task tracker at https://invent.kde.org/teams/automation/issues/-/issues.

There’s now a wiki page explaining how distros can package Plasma for the best user experience, full of accumulated knowledge over time (me: Nate Graham. Link)

On distros using gdb 12, the DrKonqi crash reporting wizard is now capable of dynamically symbolicating crash traces without debug symbols, which makes them actionable and reduces bug triaging work (Harald Sitter, Plasma 5.26.1. Link)

Added an autotest for the PNG metadata extractor (Kai Uwe Broulik, Frameworks 5.100. Link)

Added autotests for KWin’s DRM (Direct Rendering Manager) platform code (Xaver Hugl, Plasma 5.27. Link)

Changes not in KDE that affect KDE

RGB sub-pixel hinting for text is now enabled by default, which is good for users of KDE software since we respect the set of systemwide default settings rather than overriding it with our own value (Akira Tagoh, Fontconfig 2.14.1 Link)

…And everything else

This blog only covers the tip of the iceberg! If you’re hungry for more, check out https://planet.kde.org, where you can find more news from other KDE contributors.

How You Can Help

If you’re a developer, check out our 15-Minute Bug Initiative. Working on these issues makes a big difference quickly! Otherwise, have a look at https://community.kde.org/Get_Involved to discover ways to be part of a project that really matters. Each contributor makes a huge difference in KDE; you are not a number or a cog in a machine! You don’t have to already be a programmer, either. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

Finally, consider making a tax-deductible donation to the KDE e.V. foundation.

Categories: FLOSS Project Planets

TestDriven.io: Migrating to a Custom User Model Mid-project in Django

Planet Python - Fri, 2022-10-21 18:28
This article explains step-by-step how to migrate to a custom User model mid-project in Django.
Categories: FLOSS Project Planets

FSF Blogs: Privacy and freedom should be the legacy we leave, not the opposite

GNU Planet! - Fri, 2022-10-21 17:10
October 21st marks Global Encryption Day, a time that calls to mind the many benefits of an unfairly (but increasingly) maligned technology. This has given us an occasion to reflect on recent attacks to encryption on the part of governments, specifically the European Union.
Categories: FLOSS Project Planets

Privacy and freedom should be the legacy we leave, not the opposite

FSF Blogs - Fri, 2022-10-21 17:10
October 21st marks Global Encryption Day, a time that calls to mind the many benefits of an unfairly (but increasingly) maligned technology. This has given us an occasion to reflect on recent attacks to encryption on the part of governments, specifically the European Union.
Categories: FLOSS Project Planets

FSF Blogs: FSD meeting recap 2022-10-21

GNU Planet! - Fri, 2022-10-21 17:00
Check out the great work our volunteers accomplished at today's Free Software Directory (FSD) IRC meeting.
Categories: FLOSS Project Planets

FSD meeting recap 2022-10-21

FSF Blogs - Fri, 2022-10-21 17:00
Check out the great work our volunteers accomplished at today's Free Software Directory (FSD) IRC meeting.
Categories: FLOSS Project Planets

KDE Gear 22.12 release schedule finalized

Planet KDE - Fri, 2022-10-21 14:07

This is the release schedule the release team agreed on


Dependency freeze is in TWO weeks (November 3) and feature freeze one after that. 

Get your stuff ready!

Categories: FLOSS Project Planets

Interview on the Sudo Show

Planet KDE - Fri, 2022-10-21 11:57

The latest episode of the Sudo Show with Brandon Johnson and Neal Gompa has an interview with me, on the subject of Kommercializing KDE. It’s quite relevant to my goal of getting our software on the all the hardware we can (AKA World Domination) so give it a listen!

You can also listen right here:

Hope you enjoyed it! And if you like what KDE is doing and want to help its contributors make a living, consider making a donation!

Categories: FLOSS Project Planets

Web Review, Week 2022-42

Planet KDE - Fri, 2022-10-21 11:44

Let’s go for my web review for the week 2022-42.

Stable Diffusion is a really big deal

Tags: tech, ai, machine-learning, ethics

Not much new in this article regarding Stable Diffusion. That being said the section about ethics is spot on. This is the toughest part to grapple with regarding the latest batch of generative AIs. The legal traceability of the training set might end up being required (even though I doubt it will happen).


GitHub Copilot investigation · Joseph Saveri Law Firm & Matthew Butterick

Tags: tech, law, copyright, foss, github, copilot, microsoft

Alright, this going to be interesting. Pass me the pop corn. It’s definitely a welcome move in any case.


EasyList is in trouble and so are many ad blockers

Tags: tech, foss, community, browser

How a design flaw in some obscure browsers can put a community project to its knees.


Why we’re leaving the cloud

Tags: tech, cloud, business, economics

Hear! Hear! No, moving your infrastructure to managed services doesn’t make sense in all cases. You need to be in the right place in term of complexity and traffic to really benefit from it. It’s less common than you’d think due to the marketing pressure.


Feather – Simply beautiful open source icons

Tags: tech, icons, design

Nice little tool to easily produce icons in a cohesive style.


A simple static site generator

Tags: tech, blog, self-hosting

OK, super tiny and simple. This looks like a nice alternative for the big ones like Jekyll or Hugo.


A Real World React -> htmx Port

Tags: tech, htmx, html, javascript, frontend, django, webcomponents

Interesting data point about a service moving completely to the htmx and web components approaches. Not all applications are going to see such drastic improvements, that being said the change in team structure alone feels like a very good thing to me (and is more likely to be the constant in such moves).


Musings on Python Type Hints — samgeo.codes

Tags: tech, python, type-systems, mypy

Interesting examples where the Python type hints are used. This still needs improvements but it’s clearly improving.


Test smarter, not harder - lukeplant.me.uk

Tags: tech, tests, tdd, craftsmanship

Lots of very good points, I’m a proponent of TDD but I strongly agree with this. If it’s painful and not fun, find a way to do it differently. There’s likely a tool or some API you miss. Manage your effort.


Rust-like traits in C++ | dragly

Tags: tech, programming, c++, rust

Always interesting when a language influence the use of another one. I like this kind of epiphanies.


RAII: Compile-Time Memory Management in C++ and Rust :: The Coded Message

Tags: tech, programming, rust, c++, memory

Very good overview about RAII, ownership, borrowing references. All that comparing C++ and Rust in their ways to handle those concepts. Definitely a must-read even though it’s a bit long.


How Trying New Programming Languages Helped Me Grow as a Software Engineer

Tags: tech, programming, craftsmanship, learning

Definitely this. I regularly try to pick up new languages for this exact reason. Every time it improves the way I use the languages I already knew.


tdarb.org / Avoiding Featurism

Tags: tech, product-management, project-management, team, complexity

Very important points. This can easily turn a project into a death march with rampant undue complexity. Also the proposed guidelines are simple and seem efficient.


Wait vs Interrupt Culture | Compass Rose

Tags: culture, conversation, life

That’s a very interesting way to frame it. Two different cultures to drive a conversation, both with their pros and cons. Lots to mull over for me in that short article.


Conway’s Law

Tags: tech, architecture, conway, organization, business

Very good primer on Conway’s Law by Martin Fowler. Definitely recommended, obviously this is just a start and requires diving deeper in the topic.


Non-Euclidean geometry and games

Tags: tech, gaming, 3d, geometry, mathematics

Nice little article rehashing what it really means to have a non-euclidian geometry since the term has been unfortunately abused lately. Also gives a list of games to experience weird geometries.


Sound – Bartosz Ciechanowski

Tags: science, sound

Again a very nice interactive article. This time about sound, very thorough. Reminded me some of the things I learned at school (but then forgot) a long time ago.


Phantom Forests: Why Ambitious Tree Planting Projects Are Failing - Yale E360

Tags: science, nature, ecology

Planting trees to help, sure. Let’s do it properly though, sometimes that means just getting out of the way.


Barcelona-style “superblocks” could make a surprising number of cities greener and less car-centric

Tags: urbanization, ecology

Interesting research about city planning. Definitely a bigger challenge in the future for larger cities.


Bye for now!

Categories: FLOSS Project Planets

KDE neon Rebased on Jammy

Planet KDE - Fri, 2022-10-21 10:08

KDE neon builds packages of KDE software using latest Ubuntu LTS as a base. Every couple of years there’s a new Ubuntu LTS and so we build all our package and infrastructure onto that. We’ve just finished the move onto Ubuntu 22.04 (jammy) and installable ISO images are now based on that.

We’ll enable to upgrade for existing installs on Monday.

Categories: FLOSS Project Planets