A blog

Python rebuilds in Fedora

2026-06-08T17:48:00+02:00

Finally some time to gather thoughts about this big endeavour I take on every year. The third big rebuild of Python on my watch is slowly coming to an end. I start in October with first alpha release of a new Python and end in October the next year with the final release of Python and a release of Fedora.

Why

It's good for the community: we can report and fix issues in libraries as soon as they appear. (Some upstream maintainers don't care about alphas and don't like our reports, so I try to remember which ones to avoid in the initial months).

It's good for CPython: we can report regressions and bigger incompatibilities before they become a big issue.

It's good for Fedora: one of its values is "first": it's always been a forefront Linux distribution when it comes to adopting novelties, its userbase is used to things changing and collaborates with upstreams by design (that's another Fedora's principle: upstream first).

It's good for Python maintainers at my company: we know new Python plays well with the rest of the ecosystem. It will eventually become a part of the enterprise distribution, and by that time, it will be battle tested.

How

There's a copr repository where the new Python acts like a main one. There I keep building down the dependency tree. We've got a tool to query the repositories and find what is currently unblocked and can be built which is a cornerstone of the whole endeavour. Additional tooling consists of more scripts to solve other arising issues. (I must not lose my zsh history).

Month after month, release after release, I keep reporting issues, fixing them if I can, unblocking chunks of the tree and tend to the whole thing.

With around 4000 Python packages in Fedora, I aim for having under 500 "waiting" before the actual rebuild. That's when the rebuild actually starts and is done in Fedora build system (Koji) side tag (temporary pocket for isolated changes, intended to be merged to the main flow). I test critical paths - groups of essential packages for different Fedora flavors, and at the end of the rebuild we spawn an OpenQA instance with our changes. The last steps require cooperation with the friendly Fedora QA and Infra teams, always flawless.

The last part, the Koji rebuild, is what we aim to do in the shortest time possible. It's the third time I have met with Miro at his place, where we set up a garden office and worked through the queue with enough of both the oxygen and caffeine each day. Bára's excellent cooking has sustained us each time and I can't be grateful enough for her work put in the yummy vegan dishes <3.

Loose ends

There's still a lot of tribal knowledge in the process. When the real rebuild happens, we just work. When we're done, we're exhausted and the last thing we want to do is documenting the steps. However, I do my best to update and extend a team "wiki" about the whole process.

We only test one architecture: x86_64, but the rebuild happens on all arches supported on Fedora. This always causes some unexpected issues. However, bloating the copr repository with 5x as many chroots is too much of a tradeoff.

There's no way to "block" maintainers from updating their packages when we build things in the side tag. This always leads to inconsistencies and artificial bumping the package releases. Well.

The dashboard I was using this year needs some improvements. Overall it's a good addition to the process.

Tight ends

It's this kind of a job that works best in a highly focused environment and ideally in at least two people. I would be left in a much worse state if I was doing it alone in my home office, let alone in the actual one.

Will I do it again? Probably. But for now it's time to touch some grass.

You can see some statistics assembled every night at the status page.

Ostrava Python Pizza

2026-03-16T09:35:00+01:00

Pizza!

On February 21st, a small conference was held in Ostrava. I really appreciate Czech Python community for regularly organizing events to bring together old and new folks, this time including a big portion of Polish friends. I haven't really programmed in Poland, ever, but with EuroPython happening this year in Kraków, it feels I've got one foot in the doorstep of my homeland's communities. Leave through the door, come back through the window, it seems.

The talk

I delivered a talk offering a perspective on using LLMs for creating projects that are suited for one user only, and if such projects are mobile apps - also freeing oneself from the terror of the ad companies and other entities interested in highly personal data. You can watch it here: I scratched my itch and so should you.

One of the goals I had for this talk was to deliver it without slides. This increased the stress a bit, adding to the already stressful state of not getting enough sleep the night before. I like the idea of media as augmentation, but not the backbone of the talk - I keep using less words in my slides, mostly for the audience to have something to hook at. In the end, it was quite a pleasant experience, and I'm going to work this direction more, whenever possible.

Many thanks to the Python community for organizing this get together!

PEP 639 adventures

2025-07-28T18:00:00+02:00

With almost a year passing after the PEP 639 was accepted, I was pondering whether it makes sense to note down some thoughts on the process.

But, since I want to keep a record (if only for my memory), let's dive straight in.

PEP 639

In Fedora, we wanted this PEP. It standardized the licensing of distribution artifacts in terms of the license expressions (using SPDX identifiers), and in terms of including license files in the distributions. That would allow us to programmatically detect and mark license files. In the meantime (it was the end of 2023), Fedora started migration from its bespoke licensing format to SPDX, which opened the way to leverage the newly defined license expressions too.

Anything that touches legalese in software development is a tough sell. There were two long PEP threads and two previous authors. The PEP has been significantly reworked multiple times. My predecessors have done amazing job with all the research and specification definition. I thank them for their effort from the bottom of my heart.

As Fedorans, we were following the discussions around PEP, and when it looked like it could be rejected, I stepped up and decided to help bring it through the finish line. I inherited the longest PEP in history written in the span of almost 4 years.

The learnings

I had no previous knowledge of the PEP processes. I knew I'd learn on the go. I did: there was facilitating the discussion, reacting to feedback, redrafting (in rst, which I also learned on the job). Understanding multiple use cases. Understanding what is and what isn't a specification. Multiple changes to packaging.python.org (probably still not complete). Post-acceptance discussions. Waiting for build backends to implement and bring real feedback from the users. Realizing mistakes and oversights. A lot of community support and always a civil discussion, even in the moments of disagreement.

I didn't have a deadline in a traditional sense, but there was a sense of urgency: everyone, including the PEP delegate, was tired with the drag and it was quite clear that either we make it happen or it'll be dropped. While gaining velocity through a project that was spanning months, I discovered a self-hack that helped me immensely: I signed up to give two talks about the topic, one on Python Pizza in Prague (February 2024) and another at EuroPython (July 2024). They acted as soft deadlines: for the first one I researched the topic of licensing in Python ecosystem (while doing PEP edits in the background), for the second I brought the whole proposal publicly. I can totally recommend this approach if you want to have one more motivator on a project. I've been very fortunate to have the time allocated for this adventure by my employer.

What next?

PEP 639 has been first, but certainly not the last licensing PEP in the Python packaging. There have been use cases left over on purpose, with the aim to specify them in the future. The adoption in simple use cases - which are the overwhelming majority of Python projects (when the license of all distribution artifacts is the same) should be without issues. What's being discussed now, is how to express the per-distribution license expression in those rare cases when they're different. I keep my fingers crossed for the future PEPs authors!

Fluxus - Scratching my itch

2025-07-23T16:41:00+02:00

At EuroPython, three things happened simultaneously:

BeeWare sprint was held during the sprint weekend
I had an idea for an app that would actually help me
I wanted to learn to use AI for development

Before I had no knowledge of writing mobile apps. Two days later I've got an app on my phone.

Idea behind Fluxus

A period tracking app that doesn't track you, period.

I don't trust apps that store data on remote servers. Most of the period tracking apps are too bloated. I want to be able to just store the single variable I'm interested in. I want to be able to export and import data (to a file) if I change the phone. I want basic stats for seeing the patterns long-term.

By definition I didn't want to use an app from Google Play. There's an app from F-Droid I've been using, log28, but it's no longer maintained :(. Rather than forking, I wanted to try out the Pythonic way. The inspiration for the Fluxus layout comes from log28.

I showed it to a friend and have a first feature request :D

BeeWare

I love the idea of writing apps in Python! I'd love to see more open source on mobile and on alternative repositories. Having control over the data on my phone has always been interesting to me, and I would prefer to both be able to read the source code of the apps easily, and create my own designs. I hope BeeWare can be one of the tools to democratize the app manufacturing. BeeWare lets you write native GUIs for many platforms: the same code runs both as Linux program, and an Android app.

The only limitation I encountered for the Android version of the app, is that I can't specify the path to store the exported data. And for some reason I can't access the path the app stores the data (Android is hellishly good at hiding the filesystem details from the user).

Cursor AI with Claude Sonnet

First, I started typing the skeleton of the app myself, but then I remembered we're in the middle of the AI revolution, so it's time to jump in. Before hopping into Cursor AI, I went through the BeeWare tutorial and skimmed through the Toga documentation to have an overview of what's possible.

I loaded my few lines of code and started prompting. It's uncanny how fast the code appeared and was mostly working. I estimate I would be able to write this in a few days if I had full focus on the app. I've got a working prototype after roughly 12 hours and two Cursor sessions (2 hours spent on actually reading the code on the way back from EuroPython). The code is poorly designed, classes are tightly coupled, it's impossible to test it without mocking everything everywhere, but it's there.

What went well

I started with the tracking tab. I asked to create a JSON formatted file to store the tracked data. It initially stored data for each day I changed the switch state on, later I managed to convince it to only store the "true" values. Initially, it used the Python standard interface to store files which didn't work on Android, but it correctly ported the code to Toga-specific objects. The feature to store data on other days followed.

Next step was adding two other options - boxes for calendar and statistics. It tried to put them in a Box, even though I explicitly said I want to use an OptionContainer. One correction and we were back on track. When I asked it to use proper ways of adding boxes to OptionContainer, it asked me for a permission to browse web, found the relevant part of the Toga docs and applied the information correctly.

AI originally used deprecated attributes, which leads me to believe it had been trained on some older BeeWare code/apps, and corrected that only after being pointed to the issues. The corrections were OK.

Toga doesn't have a predefined calendar widget, so I was thinking of using the Python calendar module to draw it. I knew this is going to take some time to figure out. AI wrote the code in ~30 seconds, including the color marking of the days and real-time sync between the tracking app and calendar state. It was flawless.

I proceeded to ask for marking predictions (initially for 28 days), later changing that to the predictions based on real averages. Good on the first try.

The statistics tab was the biggest challenge. The display of data was absolutely broken. I was curious how long it would take to debug solely by AI, so I continued with prompting it for fixes. It added so many debugging prints, it completely bloated the code. The data in the console were calculated correctly, but the display showed nonsense. On each attempt AI claimed now it's perfect. After 16 attempts I went for the traditional eye debugging and found the same function implemented in two places. The correct (and debugged) one was being shadowed by a leftover. AI agreed with me, removed the other function and after confirmation that things work, on its own removed all the debug prints.

It fixed some alignment and display issues - impressive for a tool that doesn't know how things look like. It even wrote me a bunch of scripts to generate icons, as it claims it can't generate images directly. When I wanted to use my own designs, it generated resizing scripts and refreshed the app to display the assets.

Overall it was fast, mostly correct and the AI was able to fix the traceback issues without more prompting.

... and what didn't

Up until now, I had it all in one file that was close to 1000 lines of code. So I upped the game and asked the AI to refactor, which it happily did. Each tab is now a class, which needs the main App class when is initialized. And the main App class needs instances of each of the tab objects when is being initialized. The methods walk though the App instance to other class instances to call some of their methods. It's a mess.

I then asked it to decouple the architecture, which it agreed is a good idea, but the effects of the decoupling were visually broken and the diff was too much to deal with at the moment. I aborted the mission.

When I wanted to add tests, it generated a bunch, but a lot of them fail. They are full of mocking methods. I don't trust a single one of them. The most hilarious part was when I asked for a command to run the tests. It thought for a moment, tried out 4 commands, determined which will give me the best result, and offered a solution: "Run pytest tests/test_foo". That's one module out of four, and the only one that has all tests passing. Even though a bunch of tests are failing, AI keeps summarizing that test logic is solid, functionalities work correctly, unicorns and rainbows.

Also, the code is full of checking the availability of certain attributes with hasattr, even though I'm in charge of the whole codebase. I consider that unnecessary noise and a first candidate for a cleanup.

TL;DR

Pluses:

The speed of generating code is really impressive.
Things were mostly correct, or corrected after a prompt from my side
With small/trivial tasks AI is very helpful.
When prompted for accurate answers, it is able to look for the information online and apply them.

Minuses:

It lies. It's very supportive of each your request (the overhyped tone feels weird after a moment).
It was very persistent in readding the feature I manually deleted. It kept adding it on top of other prompts, until I asked it to redo the functionality in the way I wanted. It congratulated me on a good idea and proposed a solution very similar to what I tried to do with the manual edit. Only then it stopped tinkering with that part of code.
With many debugging attempts, random attributes of objects were deleted and readded (e.g. flex, ensuring proper spacing, or a non-existent min_height). It was frustrating to repeatedly deal with.
The nontrivial tasks, like refactoring the whole app or decoupling the logic, were too much. I consider those failed attempts.
Cursor AI AppImage for Linux freezes randomly ALL THE TIME.

Where to go from here?

After two days, I got a bit bored by the endless loop of prompt-wait-'react to the already fixed-now removed issues'. I think I'll take the complex changes from here.

A research how to package the app is needed, so that I could store it on F-Droid. I now use a debug version generated by Briefcase installed via an USB cable. I want to improve the app slightly (mark today in the calendar, display the days left to the next predicted period). The exported file needs to be retrievable from a phone. Code-wise, I'd like to improve the architecture of the app, write actual tests and generally clean up.

RPM macros cheatsheet

2025-06-16T16:24:00+02:00

Architecture macros

Basic filtering

%ifarch
%ifnarch

Macros applicable to Fedora

%ix86   i386 i486 i586 i686 pentium3 pentium4 athlon geode
%x86_64 x86_64 x86_64_v2 x86_64_v3 x86_64_v4 amd64 em64t
%arm64  aarch64
%power64    ppc64 ppc64p7 ppc64le
%riscv      %{riscv32} %{riscv64} %{riscv128}

s390x doesn't have a macro, use the string.

Full list of arch macros

Note: %{java_arches} is there if needed.

Super important note: If a package is noarch, you can't filter the arches with %ifarch/%ifnarch, %ifarch in such case only matches noarch. This only works correctly for arched packages.

PyCon Namibia - Looking back at 2024

2025-01-23T19:34:00+01:00

Power of the community

Working with Python and largely in an open-source space brings perks. Python is truly unique for the communities that form around it. People crafting webs, moving science forward, powering machine learning, geeks and passionates create a very diverse crowd. It took me at least three repetitions from Honza Javorek about his Namibian experience to start thinking: what if?

So in 2024, when I heard Mia from the Czech Python community is also thinking of going, we went for it: I sent a talk proposal which was accepted. The talk was about leveraging Advent of Code to progress beyond the beginner's phase of a programmer - an English translation of the talk I delivered on PyCon CZ 2023 (slides).

Honestly, this was the best way to arrive in Namibia. The local community will always stay in my heart! The folks there are one of the most welcoming, warm and open people I've ever met.

After 4 days of the conference, we packed, borrowed a car and headed North to Etosha National Park. Let me just say: it can't be missed if you're in Namibia. We stopped at the Cheetah Conservation Fund on our way there, which I can wholeheartedly recommend. We've seen the desert and the ocean, got caught in a heavy rainfall which lasted around 30 minutes, met countless antelopes and baboons, and drove over 1400 km in total. I haven't felt so relaxed in years, probably.

Supporting the Namibian community

The following advice is tailored for a fellow Westerner, it contains Assumptions.

We didn't know it before, but the Namibian community is very young, both in terms of age, and maturity. The whole IT industry is emerging. Don't be fooled by the appearances though, folks know exactly which problems they want to tackle using technologies. I've seen an excellent workshop on using machine learning and pattern recognition to find oases in the desert. If you plan to come to the conference, in my opinion the best way to contribute on spot is to bring ideas about technologies with practical application. Think of constraints when designing your talk or workshop: internet access cannot be taken for granted, think of services available for free rather than paid.

You can also support PyCon Namibia directly. An amount of 20 EUR will pay for one person's ticket.

Footnotes

I've got a lot of mixed feelings about responsible traveling to post-colonial countries as a European tourist, which is a topic for a long research and even longer essay, so maybe one day, when I find the proper words. Nevertheless, my advice no. 1 for anyone thinking of traveling to places which are very different from their homeland, is: find locals, listen and learn from them, contribute if you can, don't be just a tourist. Python happens to be a great social glue!

fedrq - querying Fedora repositories

2024-02-29T16:18:00+01:00

Querying repositories

Part of my $DAILYJOB is digging in multiple Fedora repositories. Every time I prepare a package update, I check whether the update has a potential to break something. Typically I set up lists of packages that require my package and build them in a isolated environment, before hitting the real Fedora. I heavily use Copr as a test bed (described in detail in the talk from DevConf 2023). In that talk I show and comment a bunch of repoqueries. Repoqueries do the job, but they're nearly-impossible to come up with (correctly) and if I lost my bash history, I'd be left crying on the floor. (Not really though, in the end I've got the talk recording \<evil laughter>).

fedrq

This is where fedrq comes to the scene. A new tool with a new approach by an incredibly active Fedora community member, gotmax23. I spent a jolly day with it and decided to create this cheatsheet to help me translate my use cases to fedrq and ease the migration.

Cheatsheet

formatters

Powerful feature of the tool; list them all with:

$ fedrq formatters --attrs

And format the output of the tool with -F <formatter>. Many more things are possible, refer to the documentation.

What package does a file belong to?

# Fedora Rawhide
$ fedrq pkgs -P /usr/bin/python3
# Fedora 39 (-b, --branch)
$ fedrq pkgs -b f39 -P /usr/bin/python3
# Koji - format output with name-version-release-repository
$ fedrq pkgs -r @koji:rawhide -P /usr/bin/python3 -F nevrr
# Copr repository (-r, --repo)
$ fedrq pkgs -r @copr:@python/python3.13 -P /usr/bin/python3

List all files from the package

$ fedrq pkgs python3-rich -F files

What's the full package name?

$ fedrq pkgs python-rich
python-rich-13.7.0-5.fc40.src

$ fedrq pkgs python3-rich
python3-rich-13.7.0-5.fc40.noarch

What packages will be built from my source component?

I can also format output to get only names: -F name or full nevr -F nevr; or skip formatter at all.

$ fedrq subpkgs python-sphinx -F nev
python-sphinx-doc-1:7.2.6
python3-sphinx-1:7.2.6
python3-sphinx-latex-1:7.2.6

The opposite: What source rpm comes my built package from?

It can take also the base name: python3-sphinx-latex.

$ fedrq pkgs python3-sphinx-latex-1:7.2.6-6.fc40.noarch -F source
python-sphinx

Provides and requirements of my components

$ fedrq pkgs python3-sphinx -F provides
python3-sphinx = 1:7.2.6-6.fc40
python-sphinx = 1:7.2.6-6.fc40
python3.12-sphinx = 1:7.2.6-6.fc40
python3.12dist(sphinx) = 7.2.6
python3dist(sphinx) = 7.2.6

# runtime requirements
$ fedrq pkgs python3-rich -F requires
python(abi) = 3.12
(python3.12dist(pygments) < 3~~ with python3.12dist(pygments) >= 2.13)
python3.12dist(markdown-it-py) >= 2.2

# buildtime requirements
$ fedrq pkgs python-rich -F requires
python3-devel
python3dist(packaging)
pyproject-rpm-macros
python3dist(pytest)
python3dist(setuptools)
python3dist(attrs)
python3dist(pip) >= 19
(python3dist(tomli) if python3-devel < 3.11)
python3dist(poetry-core) >= 1
(python3dist(pygments) < 3~~ with python3dist(pygments) >= 2.13)
python3dist(markdown-it-py) >= 2.2

Dependencies

What other packages need my binary package?

whatrequires equals to wr. whatrequires-src equals to wrsrc. -s, --src means only source rpms. -S, --nosrc means exclude source rpms.

For Python -s/-S may not seem relevant, as source and built components are usually named differently, but for any other components it's crucial, compare e.g. $ fedrq pkgs ocrmypdf -S -F requires and $ fedrq pkgs ocrmypdf -F requires

equivalent to: repoquery -q --repo=rawhide{,-source} --whatrequires python3-rich

$ fedrq whatrequires python3-rich

# It can work with virtual provides too!
# don't use it though, it only matches the literal provides
$ fedrq whatrequires -s 'python3dist(rich)' -F name

# released Fedora: both fedora and updates repos
$ fedrq whatrequires --branch f38 python3-rich

Only interested in fedora repo? equivalent to: repoquery --repo=fedora{,-source} --releasever 38 --whatrequires python3-rich

$ fedrq whatrequires --branch f38 --repo @release python3-rich

What packages require any subpackage of my srpm?

equivalent to: repoquery -q --repo=rawhide{,-source} --whatrequires python3-sphinx --whatrequires python3-sphinx-latex --whatrequires python-sphinx-doc

# wrsrc is used with the source package name
$ fedrq wrsrc python-sphinx | wc -l
821

# compared to this - it only takes care about this concrete built package name
$ fedrq wr python3-sphinx | wc -l
815

What packages require python-sphinx' components on build time?

equivalent to: repoquery -q --repo=rawhide{,-source} --whatrequires python3-sphinx --whatrequires python3-sphinx-latex --whatrequires python-sphinx-doc | grep 'src$' | pkgname | sort | uniq | wc -l

$ fedrq wrsrc -s python-sphinx -F source | wc -l
739

The Big Python Query

Get names of the source packages in Koji that require any of the given Python provides - needed for Python rebuilds.

$ repoquery --repo=koji --source --whatrequires 'libpython3.12.so.1.0()(64bit)' --whatrequires 'python(abi) = 3.12' --whatrequires 'python3.12dist(*)' | pkgname | env LANG=en_US.utf-8 sort | uniq

Fedrq equivalent:

fedrq wr --repo='@koji:rawhide' 'python3.12dist(*)' 'python(abi) = 3.12' 'libpython3.12.so.1.0()(64bit)' -F source | env LANG=en_US.utf-8 sort | uniq

Nice little things repoquery doesn't provide easily

Breakdown of the buildtime, runtime deps and their srpm names:

$ fedrq whatrequires --branch f38 python3-rich -F breakdown

Resolve the packages required by rich on runtime. Same with build time - just change the queried package name

$ fedrq pkgs python3-rich -F requires | fedrq pkgs -iSP
python3-3.12.2-2.fc41.x86_64
python3-markdown-it-py-3.0.0-4.fc40.noarch
python3-pygments-2.17.2-3.fc40.noarch

Print lines matching the required package in packages that require the given package (yeah, I can't explain it). Useful for finding packages that use aggresive version constraints. Semantically the same as our notoriously horrible oneliner: for pkg in $(repoquery -q --repo=rawhide{,-source} --whatrequires python3-sphinx); do repoquery -q --repo=rawhide{,-source} --requires $pkg | grep -E '\bsphinx\b' | grep '<' && echo -e "${pkg}\n"; done

$ fedrq wr -F narm:python3-sphinx python3-sphinx | grep "<"
# only interested in runtime? -S means --nosrc
$ fedrq wr -S -F narm:python3-sphinx python3-sphinx | grep "<"

EuroPython in Prague

2023-09-01T18:55:00+02:00

It almost feels as if this year was the first real one after Covid! When it comes to Python, 2023 has brought two big conferences to Prague: EuroPython and, after a covid break, PyCon CZ.

A short report of PyLadies' activities can be found on the official blog of the Czech Python community.

DevConf 2023: Talking about packaging in Fedora

2023-07-15T20:12:00+02:00

My daily job is all about packaging. I wouldn't have believed that such an invisible (for the outsider) topic can employ hundreds people all over the world.

Preparations

This year I wanted to talk at DevConf about something related to my work. That's a new - I have no issues talking at the conferences, but till now it was always community and education-centered. This was the first technical talk I wanted to deliver.

I learned some things on the way!

live demos aren't the greatest idea of all times. it's much better to have a static code snippets in the presentation and demo with the interested parties afterwards
researching a new topic takes even 10x more than preparing a topic you're already an expert in - I spent dozens of hours preparing
rehearse, rehearse, rehearse. 15 or 20 minutes is nothing if you're nervous, get into detailed explanation or jump to another topic in stress
also, while rehearsing, it's good to note down all weak points and fill in the information gaps. It helped me understand better my own work
reveal.js is a great presentation framework easy enough for people who don't enjoy digging in css. And publishing it on GitHub takes only a few clicks!

Effects

My talk was called Fedora package update? Assess its impact in Copr

Slides from the presentation

PyLadies at DevConf

2022-02-11T18:16:00+01:00

As winter came, we decided to keep the good streak of talks given and sent an application to the Czech DevConf. Again we teamed up with Anežka and delivered a presentation called PyLadies Community in Brno: Mutual Help to Grow.

This time we focused on what drives the community builders: the people who enable the community's main focus. There are organizers, coaches, lecturers (also called the main coaches) and we realized, in short, two things:

the motivation to join a community often isn't the same one which prompts a person to stay in a community
there are real-life skills and gains to grab other than the whatever the community is about

We hoped for a real life talk on a hybrid conference which eventually wasn't possible. But the conference org team has no power over a global pandemic, so I'll just stop whining here. Kudos to the organizers who did a great job making it work virtually!

Much satisfaction, would do it again. :)

PyLadies at OpenAlt (CZ)

2021-11-25T17:28:00+01:00

On the first November weekend Anežka Müller and me delivered a talk about PyLadies in the Czech Republic. We wanted to answer the questions people may have about what and why we do. We also shared some internal thoughts how we aim to build a sustainable format of community courses and how we deal with the inevitable perils of community activities - burnout (both on the side of the attendees and our volunteers).

The talk was in Czech. Slides are available at the conference's webpage. It's available on YouTube as a single stream, but we're hoping for a cut and enhanced version - the audio seems significantly worse than we expected.

There were quite a bunch of people attending the talk which is a nice result for a sunny Saturday. I was excited to see two of my close friends from abroad to come and hear our Czech speech.

Footnotes

I wanted to do something for the OpenAlt as I benefited from their talks and workshops for a few years in a row now. The online format gave me hope we could prepare something more country-centric, but in the end it was more about our local Brno chapter.

Martina from Ostrava's PyLadies helped us preparing the talk outline. For the rest of the talk we teamed up with Anežka and I'm super grateful she agreed to do this together. I'm still impressed how smooth the later preparations were and I find Anežka's insights about the mission and vision especially valuable. We should definitely do more in the future.

The debug tale

2021-08-15T17:38:00+02:00

Debugging

The word anyone attempting programming knows from the almost beginning. You know, the moment you learn: if it doesn't work, look at the traceback, then add 153 print statements, then try to understand where the heck you forgot the missing parenthesis.

When some clever programmers told me to start using debugger, I gave it a try. But even after attending some workshops and reading tutorials, I wasn't sure why I'd ever want to use it. After all, I could just run the application and see where it crashes.

The right tool for the task. Which task?

Today I think it's a matter of presenting the use cases. The typical story would be: I write the application and it behaves strangely. So I run a debugger and....

My guess is that this is where the beginner stops. When all you've ever written are one-file scripts or very small programs, it sounds as if it's an overkill. Print & tracebacks will do.

BTW, I recently found some clever senior programmers who admitted they use print too! No reason to be ashamed!

Let me present the other use cases that a junior may be more likely to meet.

I have this script/tool that should do X. When I run it, it doesn't do X, instead it produces Y. I want to understand why.

or:

I want to contribute to a big project that I found on GitHub which has got plenty of tasks labeled "Good first issue". There is a bug - when you do A, the B's output is corrupted. I want to understand the relationship between A and B.

or - my eureka case:

I use the project that bundles a lot of libraries within. I want to use it with the libraries from the system instead. I want to test that it still works as expected.

The common features of those use cases are:

I'm not the author of the original code.
I have to read a lot of code lines in order to start working on a task.
The applications I want to understand don't have the conventional problems - they don't crash, no traceback is involved.
The more complicated program, the more context there is to keep through many function calls.
Constant adding and removing 153 print statements would be pain in the... fingers.

Humans - not the right tool for the task

As a human without modern tools, you'd have to find that line and start displaying stuff: print variable's contents, check the function's call, find the function's definition, print some variables there, see there is another function's call making some transformation with your initial variable, so check its definition and -- why not -- add more prints there.

You could go the other way around and start with some import buried deep down in the module, and gradually find your way up to the user interface.

Humans are capable of (if really motivated to...), but in fact don't excel in keeping the context through many files and levels of hierarchy. A computer is much better suited for the task.

Depending on what tool you use, setting up a debugger can be as easy as setting a single breakpoint on the line that you're interested in. Now you have the tools to step into the functions and dig as deep as you need to. You can see the contents of the variables or arguments that were passed on the go. You can see the boolean evaluation of the statements and play interactively with the program's current state.

Into the details

I came across this talk by Nina Zakharenko which I recommend if you want to get a sense of how a debugger can be useful for you: Goodbye Print, Hello Debugger!

Let me include also the article about the various debugging techniques (not focused entirely on debuggers) which may be interesting in those traditional use cases, when it's your own application you deal with. Ultimate Guide to Python Debugging by Martin Heinz provides the means to having a clarity of how your program actually works.

Post scriptum

Finding a way to include the debugger into your workflow is not a trivial quest. If you feel you haven't really found the convincing use case yet, there is nothing wrong to it.

In my original case, I realized it'd be great to use the debugger just as I headed to the last item on my library's list. I would have saved many hours if I used it right from the start. The taste of learning is sometimes bitter.

Since the eureka moment I started using the debugger baked in my IDE more often. It is especially helpful when a script written by someone else doesn't produce the output I've expected. Ironically enough, the tool designed to find the flaws in the code seems to be as good in debugging humans.

Oh, and by the way... If someone tells you that writing a readable code is important, just believe them.

Junior's mindset

2021-06-22T19:22:00+02:00

The good, the bad and the scary

Ups and downs of your next technical role can be stressful. They are to me. You are uncertain pretty much all the time and your experience from a different field doesn't really match the environment you look at.

The good

Let's start with the good ones! It certainly feels great when you solve an issue that was lying around for a few years. The timeline of accomplishment can be:

 Bug created      /me: print("Hello, world")        /me: Solves the bug
───|───────────────────────|────────────────────────────────|───►
 2015                    2017                              2021

Or: you dig into some problem and understand what causes the error. You bring the issue to the developer's attention, possibly already with a fix, and wait thinking: have I done legit job? The next day you see all the happy emojis on your Pull Request and people are telling you "good job" and merge the changes and the rainbow appears above your desk.

The scary

The uncertainty. You think you did a good job or a good-enough job, and it could be - but there is always something to improve. Every task is a new task, every way is a new way, you look around for gotchas and still not get all of them. Now, this isn't anything particularly bad. It's understandable you're new, don't know the conventions, need to learn the stuff. No one makes you feel like you're a con. You're probably the only one thinking that. And you need to prove to the whole world you're worthy.

The bad

It's not a role that's stressful, it's you bringing the pressure upon yourself. In home office regime you can't go to the office and share team's vibe. You don't have the usual means of disassembling the bomb by getting along with people, small talking, venting the frustrations and sharing the joys. You don't get as much of the external validation, such needed at the start. It's you and your desk and your computer, your mailbox and all the thoughts running through your head.

What helps?

Vent with someone you trust: be it your peer, manager, partner, friend.

Write a blog post which you hide in drafts for a few weeks.

Find some other juniors or career switchers in similar mode, talking to them can be beneficial, you will no longer feel like an isolated island.

Go to the gym. Why beat the whole world when you can beat yourself?

Write a brag document - record every success you've made so far. Read it often.

And just keep hanging in there. The mood will change in time as you get more experienced and independent.

And... at some point you may even reconsider publishing that buried post. There are others on the same path out there. Help them feel less lonely.

Git submodules

2021-05-05T17:19:00+02:00

As I swim through the new waters, some nasty gotchas wait for me in the currents.

Overture

Many times have I encountered a GitHub repository with some folders that look more like a hyperlink to another folders.

An example from Pelican themes looks like that:

Notice the icons with the arrows and kind of weird name of the blue entries.

Tricky part

I wasn't paying much attention to them until I had to.

Scenario

You want to clone a repository containing those linked folders. So you run git clone git://<your-repo-url> expecting the whole repository will be cloned to your disk. It is, but without those linked ones. They are empty, no files, nada.

What not to do

Enter the empty folders and try to git pull the contents. This won't help.

What is possible to do

Ask a more senior colleague if you have one nearby. Alternatively, ask your favorite search engine how to download the folder contents. The only problem is how to phrase the query to actually find anything meaningful. I did, it took me enough time to see some sense in publishing the note.

What actually to do

Look for git submodule or just read this chapter from excellent Pro Git book.

Go to your project root directory and run the commands:

git submodule init
git submodule update

The empty folders shall be populated now. :)

Edulog #4

2021-04-05T12:49:00+02:00

That's been a ride. A bit of cold in the middle of March and diving deep in RPM ecosystem. I tried to sink into Factorio to relax, but it keeps feeling as if I just went from one job to another. It has some real charm though, so I hope I'll find my way around it.

Accomplishments

In the middle of March I joined the big Python team course as a home assignments couch. Maybe I should focus rather on good coding practices, but I figured - I miss community courses and still have some time and energy, so I jumped right in the turtle pictures ;). This one feels completely different though. Without the power from personal encounters (saying me - not really a people's person), the whole process is much more mechanical. I start to understand the benefits of MOOC course one community member proposed around a year ago to rather uninterested audience.

Last few weeks I learned / read / attended

How to add desktop entries to programs in GNOME environment :).
How to test RPM packages using containers.
How to organize changes into readable commits (and that git rebase --interactive is indeed my good friend).
I wrote the solutions to Lab 1 and Problem Set 1 from CS50 course. I realized that C requires a different approach and understood what some people mean by thinking in a language. Being limited by what can be done, made me craft my algorithms in much careful (and, to be honest, mathematical) way I would with Python.
I went on a meetup regarding financial negotiations. A bit out-of-time as I am just past this phase. I'm happy to have attended though, I met a long-lost friend there and spent a super interesting evening with CyberMagnolia ladies.
And to Daria's lecture on Junioring 101 for Junior.Guru club. This time with a longer story about what a Site Reliability Engineer is and her own path towards tech - insightful and fun.
And to online board game evening with my team. After a year of pandemic it didn't occur to me that there still exist some ways to hang out with people. Weird, I used to play a lot on kurnik.
Following Lumir's advice to learn new habits by placing them next to our old ones and having decided I won't continue on running in my (rather broken at the moment) sport's routine, I'm in the middle of creating habit of ~1-hour-long walks with podcasts. Working well so far!
Continuing on The Culture Map by Erin Meyer. I see that my uncertainty regarding how to behave in business situations is justified. I identified some situations that made me uncomfortable in the past which were just a neutral part of the source culture. Hopefully I'll find time to write down some notes from the book.

Draw a map! (2/2)

2021-03-20T14:00:00+01:00

In the first part you've learned about a tool called uMap. For some use cases a static map is enough.

OpenStreetMap is however very much alive and changes every second. You may want to reflect those changes in your map. Real time requests aren't feasible with current OSM state. If you try to send too many of them, you may end up with a ban on Overpass servers.

Let's say you'd like to update the map nightly, which shouldn't be too hard on Overpass.

Where to for lunch?

My goal was to display all restaurants where I can eat in the region I live. I wanted to filter for places which serve plant-based menu and display them on the map. This way I not only know where to go for lunch, but also have a visual clue when it comes to updating non-existent places.

Let's see how to proceed with such a map.

At this point you know:

how to ask for the data you're interested in
how to take the data from Overpass and put them in the map

What's the goal?

Automate the process and set it to ask for data periodically, every night.

Git scraping for the rescue

You need a machine to perform some actions in the middle of the night. The actions contain:

requesting the data
storing the data

Where to store data?

For small data samples (like restaurants in your city), GitHub can be a place of choice. Just remember, GitHub was not designed to be free database. It won't let you store too much data in a repository.

How to request data?

There is a technique called Git scraping shown by Honza Javorek on one Pyvo.

GitHub provides a tool called GitHub Actions which you can set up to perform various tasks for you. Like for example... calling an API request and, in case the response file is changed, commit it automatically to a repository.

Git note

If you're reading this and struggle with terms like 'repository' or 'commit', consider learning about Git basics first, for example here.

How to get a valid URL to send requests?

Once you've built an Overpass query that satisfies you, look for Export option in the menu. Then find Query and click on compact in Convert to... option. A new pane with the query will open. Copy the displayed query and try it in another tab. It should provide JSON data - you're set.

To make things as easy as they can be, let's use bash command curl to make a request. curl will take a URL to call as an argument, and the output will be directed to a file, like this:

curl 'url_to_request' > my_data.json

The actual example is a bit longer, mainly because API parameters in Overpass are quite verbose. Check my script run.sh. I call for 4 sets of data with 5-minute breaks in between.

The process of calling and storing takes place automatically. See my configuration file in scrape.yml. Let's ignore Python rows as they are not necessary for this project. The configuration says that each day at 2.15 AM an Ubuntu machine copies the code from my repository, executes the run.sh script and in case the files have changed, commits them to repository as user Automated.

So the script runs every night but it commits now and then - when someone changes the restaurant's data. The big benefit is I can track changes to the date.

As a result there are several JSON files in output folder. Let's connect them with the map!

Point the map to remote data

Pasting data to the map as it was shown in the previous post isn't the right way here.

I want to display different layers of data (100% plant-serving places, places with some options...- one layer per each JSON file from my repository). For each layer I want to set different color and properties. This is achieved by setting Remote data in Layers.

There is a field for URL with data. That's great. As it happens, we have an accessible remote storage of the data - we only need to paste the URL to raw data, so that uMap parses it correctly. You'll get the raw data by clicking on the respective button.

Fill in the marked fields and click Save.

One layer of data is imported and, what's more, it will be updated every time someone changes underlaying information.

The result

See full screen

Edulog #3

2021-03-12T17:03:00+01:00

I started the new job on March 1st and all of my unfinished texts remain this way. The format of this weekly accomplishments may become more bi-weekly...

Last week I learned

Mostly the stuff related to my new workplace.

RPM packages

My daily lecture - Packaging Guidelines
- And their Pythonic version
How to review RPM spec files

Python packages

Tutorial on packaging

Community related

Crash course on diversity in Python

German snippets

I continue to fill in Anki with new vocabulary and revise the old one. I find it the best flash card application, mobile AnkiDroid can be found on f-droid.
"es" can be skipped if the whole clause plays the role of subject (2). If the main clause stays at the beginning, there must be pronoun subject present, and the clause is followed by a comma (1a, 1b). The only applicable pronoun subject is "es", "das" can't be used instead.

1a) Es ist notwendig, alle Aufgaben durchzusehen.

1b) Notwendig ist es, alle Aufgaben durchzusehen.

2) Alle Aufgaben durchzusehen ist notwendig.

Polish snippets

I read Król by Szczepan Twardoch. The best way to spend your evenings in lockdown.

Edulog #2

2021-02-25T13:03:00+01:00

My "free" month is at its end and I decided to spend most of the time doing whatever I felt like to. This includes taking long walks, playing board games and watching Doctor Who's last season.

I received plenty of information about onboarding at my new employer which is held online. Even though it was my call to switch jobs in the middle of pandemic, I still feel a bit uneasy when it comes to 100 % remote work for the next months.

Accomplishments

changed processing of the underlying data of my map. I added a Python script that sorts restaurants into 4 categories depending on present tags.

Last week

Read about Pattern Matching, the new planned feature in Python 3.10 and tried to wrap my head around the concept.
Attended a few talks on DevConf.
- Junioring 101 by Daria Grudzień - I need to implement all of this :D
- Containers are Linux - hands-on workshop with the basics of virtualization. Quite fun and rewarding.
Listened to a few episodes of Easy German Podcast and I still find it the best out there for B2 level. My favourite podcast for walking!
Listened to an episode about women in project management called Sassy or assertive followed by reading the beginning of famous book Lean in by Sheryl Sandberg. Both very interesting but I find the diversity and discrimination topic increasingly harder to take, knowing I have no tools to change the system. I'd better focus on my job.

Plans and hopes

I found out about CS50 and decided to take a look at C lectures.

Draw a map! (1/2)

2021-02-24T14:38:00+01:00

uMap

uMap is a tool to create custom maps on the OpenStreetMap layers. In order to start creating maps, one needs to have an OSM account and click on "Create a map" on the uMap homepage. There is a few possibilities how to get data to the map.

Language course in Wrocław

Your friend is going to Wrocław for a language course. They want to know where to eat the best pierogi in the city. You want to show them additionally the campus area as well as some best walking routes.

Requirements:

you need a pinpoint, shape and line drawings on the map
the map shouldn't change: once you finish your edits, that's it

All of this is achievable with the three options on the top-right map menu. Additionally, one can change the background to the most suiting the needs of the moment.

The final map can be embedded to your site with a piece of HTML code. See the same example as interactive map:

See full screen

Use case 2

Your friend now knows where to go to learn, drink beer and eat pierogi.

Let's keep it even more stereotypical.

They heard that there is plenty of old churches there and they want to take a look at some of them. It's Poland so marking each church manually might be a tedious task. It would be good to be able to bulk import data about churches.

Requirements:

no more drawing manually, automation needed
the map shouldn't change: once you finish your edits, that's it

The useful tool for the task is Overpass Turbo which runs queries to OSM database and returns the results as JSON files.

First, you need to establish what we're looking for. Using your favorite search engine for "church tag OSM" will lead you to this Wiki page.

It's time to go and ask Overpass Wizard about "building=church in Wroclaw". When the query is ready, click "Build and run query".

There is, as expected, plenty of results. Overpass shows them by default as a map layer but there is another tab available - Data.

Important note

For objects that are not nodes, but polygons (as churches and other buildings often are), uMap doesn't work properly yet.

In order to make it work, you shall change the query in the left panel. Replace the lines 17-19: out body; out skel qt; with out center qt; and click the button Run on the top-left menu. This will ensure that each polygon has a central point and can be drawn on map.

Clicking on "Data" panel you'll see them formatted as JSON. How convenient! Let's copy and paste the data to uMap.

In the import field there is plenty of possibilities: data can be imported from file, url or directly to the map. Let's paste it directly. Format in this case should be osm and the layer to import is up to you.

Click "Import" et Voila!

See full screen

Note that it's perfectly possible to import data to the first map as another data layer and provide your friend with both hand-drawn and imported objects.

Final words

Neither of maps will ever change (unless you edit them manually). The next time I'll show how to ensure the data is updated automatically on a regular basis.

Edulog #1

2021-02-18T14:30:00+01:00

Accomplishments

Vege JMK - dynamic map showing raw data + GitHub repo with data
static map showing preprocessed data (Proof of concept)

I shall continue on the preprocessed one, it reflects the reality better.

Last week I learned

how to create maps using uMap, plenty of clicking and some fun included.
how to use GitHub Actions to deploy static website to a branch that is then served.
what is quick sort and how to implement it in Python.
how does the .spec file look like. RPM packages are created from them.
about the ways some communities work and why do they part their ways when business comes into scene. Inspired by the story of HegdeDoc, once derivate of HackMD.io which I use a lot.
I can't estimate development time well. It took me around 5x more to create the first map than I expected.
a lot of various stuff from junior.guru club. I wasn't sure I'll benefit from there, I am.

I intend to purchase the access once I start getting paid again :)

Plans and hopes

listen to the story of ownCloud CTO who forked his repo and started Nextcloud
check out the Fall of civilizations podcast

Advent of Code 2020

2021-02-17T16:36:00+01:00

Intro

This year I joined the challenge with the intention to make it to the end, no matter what. I did it out of curiosity: with the aim to challenge my Python skill and have some brain exercise. As a beginner I solved first puzzles in the previous years but didn't make it to the 3rd day. This year was supposed to be different.

Maybe making it to the end doesn't sound like a good-enough motivation, but it worked for me. The first days of the challenge were quite easy, backing up the the main motivation. Seeing your first earned stars makes you feel good about yourself, so you want to push your limits even further ;).

Puzzles

Tasks complexity grew gradually but that was to expect. I didn't really get to do anything else in my "free" time except for AoC in December. This needs to be counted with when joyfully joining the challenge.

AoC doesn't require any programming style, that's up to you. People in the subreddit were sharing their insane solutions in Minecraft, Factorio or even the whole event (all 25 days!) as Python oneliner. My idea was to refresh a bit of everything, so the solutions look like Polish bigos.

bigos, do try it at home source

I used the classes once or twice, some of the puzzles were short enough to be solved with a few lines without special ordering. With most of the puzzles I defined at least some functions as I split the task to simpler problems and then was going to tackle the big complex one.

I realized that a big challenge for me is to sew up the big solution from small subtasks. At some days the puzzle was too complex to see the solution straight away. I solved the smallest parts then, like applying the rules and evaluating the round, and at the end I engineered the working whole from the small pieces I had. This typically led to some level of code ugliness.

Some surprises on the way

There was A LOT of input processing. Every day new structure.

A great variety of tasks appeared. One day you navigate the ship, another create 4D cubes just to implement the input validation rules the next one. Jumping from one context to another was a must.

Some problems required hours to crack. Being still more of a beginner I saw most of the problems for the first time. I don't regret a single hour.

The best help to a programmer? Notebook and pencil. The second best help? Community to ask, support, laugh and uncork the bottleneck when there comes one.

I realized what do the people mean when they apply the categories of not/elegant to code. There are some places in my solutions which could use some better approach, but I wasn't fit to solve it myself right away. Sometimes I didn't know how, sometimes it would just take too much time. This could have been the opportunity not to brute force the solutions, but often this was the quickest way to get to the end of the task. I intend not to start code shaming myself though.

Aaaand it is easier to code with a fever than to code with a headache. Checked so that you don't have to.

Community

I learned a lot from reading the solutions of the small group of PyLadies here in Czechia. When solving a puzzle I could typically see only one way to do it - mine - and seeing how differently the others think through issues was genuinely refreshing. A piece of competition we had using our private Leaderboard was another element of keeping the motivation up and our common Slack channel was the first place I often directed my steps to when having a struggle.

Learning opportunities

Some first timers:

Python standard library gems: itertools, collections
regular expressions (Python library re): The first day of using regex was painful. The 15th - easy peasy.
lambdas: great tool for lookup dictionaries
I became aware of the big-O complexity, that there exist more and less efficient data types and operations

Growing in confidence:

navigating Python docs. I started using Zeal and like it a lot
understanding the task, using test data to validate my solutions
breaking the task down to small pieces
coding without debug printing every second line (I can keep some abstract representation of the ongoing transformations in my head)

My final score is 48/50. In the last unsolved big task I have to create a picture out of very small pieces. As I didn't enjoy the first half of the puzzle at all, I just can't force myself to sit and finish it off.

The end

If I started going through 2020 again, I would most certainly solve some of the puzzles differently. With new skills and foreseeing more problems as they occur, I would look for another approach. I feel tempted to go through AoC from the previous years as an ongoing exercise during 2021.

Note to self: don't be too optimistic about this one.

Like Columbus but better

2021-02-15T17:48:00+01:00

It's hard for me to go out without a purpose. Hiking in the forests, meeting some other people - count me in. Trying all the tram routes in the city - of course.

But then the pandemic comes. Or there is no one available in the city. Or you've seen all of the tram, bus, trolley, and city train routes.

That could be a reason to stop leaving the flat.

I hacked this laziness of mine by starting editing OpenStreetMap. The map isn't primarily a map - it's a big open source database. That means anyone can edit it, and there is plenty of possibilities, from very easy to quite complicated ones.

Where you've encountered OSM

If you think you don't know OpenStreetMap, you're probably wrong.

This is the default map used on Facebook. (They seem to have forgotten to attach the license attribution. Those little distracted heads!)

You may know one of the popular offline mobile applications, OsmAnd. If you don't, try it. It has some great features helping with planning mountain hiking, especially altitude profile.

The well-known maps in Czechia, mapy.cz, use OpenStreetMap for showing foreign countries data.

Editing map

First we need to talk about where to get source information from.

Data source

As a general rule one mustn't map out of proprietary data sources like Google Maps. The objects that are added to map should be ones you've checked yourself - you went there and saw it with your own eyes. It's called "survey" or "local knowledge" in the data sources and it's the most important thing you should know about OSM.

No automatic imports, no drawing from satellite photos when editing Czechia or broadly: Europe. It's a community project and anyone can become a contributor.

Point of interest (POI)

Each point of interest (like shop, bar, cinema), line (streets) or polygon (buildings, areas) consist of tags. A tag is a key-value pair.

Drawing paths can be also fun, but today I will focus on editing POIs only.

example tagging of a POI - restaurant

Many of us have a thing or two that are important for us in the city. It may be wheelchair accessibility, free parking, public toilets, recycling points, outdoor seating or type of diet in the restaurants.

A protip gratis: There is no sense in trying to map everything around you, you'll become exhausted and demotivated very soon. Pick something you care for or is fun for you. It's better to be a constant contributor on small changes than big one-time shot.

One of my things is adding vegan places to the map. Whenever a restaurant has a considerable amount of vegan meal on menu, I take a photo of the door labels and edit it at home. As you can see in the image above, the respective key is "diet:vegan" and the value should be one of yes, no, only.

when editing a restaurant at home, I update all the information, not only diet

Mapping the defaults

There is an issue with no, though. The original philosophy of OSM was: we don't map defaults. So if in Czechia the default is "no vegan options", we shouldn't add the tag "diet:vegan=no" to map. For the same reason one shouldn't map for example the possibility to pay with cash.

These days it changes, mostly because of rising popularity of mobile applications like StreetComplete, which gamify the tag hunt. The more people use them, the more defaults are being mapped and it seems there is hardly anything that can be done to prevent the trend.

The defaults may be also interesting for people building their own applications on the top of OSM data, eg. rendering 3D city models. As a side note, beware typos, it may end up like in this case.

Finding your tag

OSM has got a tremendous Wiki. It so big it's overwhelming. One of the greatest features there are the tags explanations.

It happens a lot to me that I'm not sure how to tag a particular thing. When preparing a talk, I was looking for a dog hairdresser to build a funny example. Typing "dog hairdresser tag osm" to my favorite search engine resulted in an immediate shot: the answer.

I highly recommend diving into the Wiki to look for the answers.

Editors

To edit maps you need to create a free account on OpenStreetMap.

Then you can edit:

directly in the web browser using iD editor. See guide for more details.
using a desktop application, like JOSM. See guide for more details.

Once you find an object you want to edit, you are free to add, edit or remove a desired tag.

I mentioned StreetComplete earlier, that's another approach to OSM. It's a mobile application (available on both F-Droid and Play Store). Here you don't plan what to add to map, it's designed the opposite way: it navigates you through quests in the city. When you walk past a quest, you can answer a simple question: "Is XXX still here?" or "What kind of YYY is here?" There is gazillion types of quests, I have disabled around half of them. :)

Every time you upload some of the answers, you get plenty of stars and some achievements get unlocked. You may find yourself hunting the quests in the places you'd otherwise never go.

Consider yourself warned.

What does it take to create a blog

2021-02-09T21:11:00+01:00

Why blogging?

My old domain was unused for the last few years. I had little idea what to put there though.
Having a showcase of the things I do which may be interesting for the other people.
I like writing and miss it since I switched to tech.
There are all those tips from seniors to juniors about writing down the lists of what you've learnt. This makes sense as juniors tend to underestimate their progress in time. So I treat this as an opportunity to have some edulog, maybe helpful for others, maybe just for me.
And, of course, I just wanted to build something with my own hands! Well, not from scratch in this case.

To blog or HOW to blog - that is the question

As a teenager I just created an account on Blogger and successfully blogged for another 10 years or longer. Blogger belongs to Google now and will probably end in a few years.

And being a wannabe coder, well, you just kind of have to create your own solution, isn't it right? I've been using Python for pretty much everything in the last three years. Those, however, were just scripts. You run them with python file.py and never actually get to build a whole solution. I felt like I lack the experience in gluing things together. It seemed like a natural solution to build upon my Python knowledge.

Django? Yes, but.

How about Django? Django sounds cool! And I've been to a Django Girls workshop, so this couldn't be that complicated, could it? I've spent a great time playing with a web application in Django. I really have! The app is connected to a Postgres database, uses those cool Jinja templates, I even used Bootstrap to make the site responsive, wrote a nice admin interface and made it possible to use Markdown in the blog posts.

Then I realized I need categories and plenty of other changes that will require more time spent digging in application models and Jinja. I started reading about deployment and went through what Heroku has to offer.

I learned about the DJANGO_SECRET_KEY when I published the code of my app on GitHub and immediately got a warning e-mail that I've compromised something important.

The time has passed and I wasn't any closer to having the actual website out there. In fact it felt like learning programming: with each step I was even further from my goal as I realized how much more I need to learn to make it happen.

Static and simple

I went to look for something more down-to-earth. I remembered our project's blog which was on the other side of the complexity spectrum: there were Markdown blog posts and deployment on commit on GitHub. No databases, minimum code, static site - suddenly this sounded so beautifully simple! Why to overcomplicate things? I took a long look at that other blog and realized it was built on the extension to Pelican engine, which is written in Python. I looked also at Jekyll and later Hugo, but decided to stick to what seemed like a nice case of gluing task I intended to perform.

Pelican

First things first: I went through all the Pelican themes. I was looking for something minimalistic yet pretty with a support of categories and optionally tags. That was surprisingly tough task. One of the last on the list was MinimalXY by Petr Nohejl (funnily enough, a developer from Brno) which I felt in love with as soon as I saw it.

So I was decided and could frantically start with edits:

deleting plenty of code I didn't want. That was a nice exercise in reading someone else's code.
removing Google Analytics related code for now as I'm not sure I want to track anything here.
installing the Open Sans font locally rather than fetching it from Google Fonts.

Out there

I was never inclined to frontend and have limited knowledge about its technologies. The edits I've made were nice small tasks forcing me to look for explanations around the Internet. It makes me still a bit uneasy that I don't understand everything in the project.

Inspired by Honza Javorek's weeknotes script I made a template generator to make it easier to add new posts. Thanks! Many other inspirations came from the open source projects on GitHub. I took a look at deployment routines, went through some people's configurations and repository structures.

And all of this crash course took place in around a week. This time I feel like a winner :).