Stepping into Leadership

Heading the Attendee Services team, my responsibilities were centered around answering the attendees requests during the year, managing the ticketing system, registration, child care and the distribution of swag. Organizing these essential services required lots of planning and coordination. The success of these areas was not just a testament to my efforts but a reflection of the hard work and dedication of the entire team. Huge thanks to everyone from my team who helped with all these tasks, got up early and worked all day to ensure everything went well!

The Community

One of the most fulfilling aspects of a WordCamp is the sense of community it fosters. This year, as every year, we welcomed a diverse group of attendees from across the globe—each eager to connect, learn, and share. It was a pleasure to meet so many new faces and reconnect with old friends. The energy was palpable, filled with a shared passion for WordPress and technology.

Supporting Families

One initiative close to my heart is making WordCamp a family-friendly event by providing child care services. Recognizing the challenges parent attendees might face, we ensured they could engage fully with the sessions, knowing their children were cared for and entertained. This effort not only enhanced attendee experience but also supported inclusivity within our community. As a parent I highly value this initiative and I’m proud we managed to organise it this year.

Reflecting on the WCEU journey

Since the very first WordCamp Europe in 2013, I have been actively involved in various capacities, watching it grow and evolve. Each year has added a layer of experience and deepened my commitment to this extraordinary community. As we look forward to next year, I am excited to continue contributing to an event that has been a significant part of my journey in the WordPress world, enhanced my organising skills and helped me build so many connections.

Thank you to every participant, speaker, and volunteer who came together to make this year’s WordCamp Europe a cornerstone for learning, sharing, and community building. Here’s to continuing this wonderful journey and making next year’s WCEU in Krakow, Poland even more spectacular!

The post Celebrating a Decade at WordCamp Europe: My New Chapter as a Global Lead appeared first on it.ivdimova.com.

1. In the prompt specify a background, on which the image will be generated – white, yellow or whatever other easy to determine color. A constant background makes it easier to be removed programatically.
2. Python approach: we can use the PIL(Pillow) library for image processing, identify the background color and remove it, but it’s a way easier to use rembg – https://github.com/danielgatis/rembg. Rembg is a tool to remove backgrounds from images and works quite well in my experience. Can be used via cli as well. Let’s see an example.

pip install rembg

from rembg import remove
from PIL import Image

def remove_background(input_path, output_path):
    """
    Remove background from an image using rembg.
    
    Args:
        input_path (str): Path to the input image
        output_path (str): Path to save the output image
    """
    # Open the input image
    input_image = Image.open(input_path)
    
    # Remove the background
    output_image = remove(input_image)
    
    # Save the output image
    output_image.save(output_path)

# Example usage
if __name__ == "__main__":
    remove_background(
        input_path="input_image.png",
        output_path="output_transparent.png"
    )

I made one of my LoRA models to generate me an icon for yoga studio on a beige background. And here is the result with rembg:

3. PHP approach – in php we can use the gd image library to draw a new transparent image and copy over it all the pixels that differ in color than the background.

<?php

function remove_background($input_path, $output_path, $tolerance = 30) 
{
    $source = imagecreatefromjpeg($input_path);
    $width = imagesx($source);
    $height = imagesy($source);

    $new_image = imagecreatetruecolor($width, $height);
    imagealphablending($new_image, false);
    imagesavealpha($new_image, true);
    
    $transparent = imagecolorallocatealpha($new_image, 255, 255, 255, 127);
    imagefilledrectangle($new_image, 0, 0, $width, $height, $transparent);

    $corners = array(
        imagecolorsforindex($source, imagecolorat($source, 0, 0)),
        imagecolorsforindex($source, imagecolorat($source, $width-1, 0)),
        imagecolorsforindex($source, imagecolorat($source, 0, $height-1)),
        imagecolorsforindex($source, imagecolorat($source, $width-1, $height-1))
    );

    for ($x = 0; $x < $width; $x++) {
        for ($y = 0; $y < $height; $y++) {
            $rgb = imagecolorat($source, $x, $y);
            $colors = imagecolorsforindex($source, $rgb);
            
            $is_background = false;
            foreach ($corners as $corner) {
                if (abs($colors['red'] - $corner['red']) < $tolerance &&
                    abs($colors['green'] - $corner['green']) < $tolerance &&
                    abs($colors['blue'] - $corner['blue']) < $tolerance) {
                    $is_background = true;
                    break;
                }
            }
            
            if (!$is_background) {
                $color = imagecolorallocatealpha(
                    $new_image,
                    $colors['red'],
                    $colors['green'],
                    $colors['blue'],
                    $colors['alpha']
                );
                imagesetpixel($new_image, $x, $y, $color);
            }
        }
    }

    imagepng($new_image, $output_path);
    imagedestroy($source);
    imagedestroy($new_image);
    
    return true;
}

remove_background('input.jpg', 'output.png', 30);

What we do here:

• Create new trasperant image with imagecreatetruecolor()
• Sample colors from all four corners of original image. Assumption: corners usually contain background color.
• Pixel Processing: For each pixel: Compare its color to corner colors. If the color is similar (within tolerance) to any corner = background. If background = leave transparent, if not background = copy pixel to new image.

Here is the result:

Of course none of these approaches works perfectly in all cases, but we can get pretty good results, especially with some more experimenting with the background color and the code settings. Enjoy!

The post Transparent images appeared first on it.ivdimova.com.

That’s a photo of me. And at the same time it’s not, because this is an AI generated me. So is it me or it’s not? ?

Guess the answer is yes and no. However this post is not about philosophical questions, but about how to generate all kind of images based on specific training. The AI model used for this generation is Flux on Replicate, trained on a photos of me as a LоRA model. What are LоRA models? LoRA or Low ranking adaptation for LLMs are a lightweight way to create a specific training . They are relatively small models, that apply minor modifications to standard LLMs models in order to adapt them for specific tasks. LoRAs provide a quick and fast way to train a model on a given task, which can be generating photos for blog posts, presentations or well, yourself.

What I used to generate the image above is Flux by Black Forests Labs, which seems to be the most popular image generation model lately, but you can use another one like Stable Diffusion. Flux models are trained on 12 billion of parameters and are capable of generating very realistic photos. Replicate on other hand is a cloud platform, that allows you to run AI models and train these via easy and well documented way.

So to come back to the photo above, I’ve used 9 photos of myself and followed up the guide here – https://replicate.com/docs/get-started/fine-tune-with-flux . While you can do the same with the API and there is a Python and Node.js example provided, I chose to use this web option https://replicate.com/ostris/flux-dev-lora-trainer/train . In short what you need is 10ish photos to train the model on, preferable these should be from different angles, clear and simple. I didn’t do the best job selecting these, most of my photos were with sunglasses and wearing accessories, which makes the model to produce some debatable results, but still quite good. There are several more settings that you can use – training steps, auto captioning using Llava v1.5, link to upload the new LoRA to HuggingFace, etc. The most important part here is to select an unique TOC – trigger word which you will use to trigger the LoRA model in your prompts. When ready, click “Create Training” and wait a few minutes. When the training finishes successfully, you can find the new LoRA under Dashboard -> Recently pushed models. When you click on the model, you will be presented of a few options to try your new LoRA – web at the Replicate playground, Python, Node.js, HTTP or Cog(a tool for containerasing AI models). We will look again at the playground option. The prompt is up to you, but you have to be careful to include the trigger word for the LoRA model. There are a few interesting setting to play with:

• image, to use as an image to image generation option
• mask image
• format
• LoRA weight
• Extra LoRA
• Extra LoRA weight

To me the most interesting was to play with the lora_scale, which defines how much priority you want to add to the training and the extra_lora, which allows you to get a link to another LoRA model from HuggingFace to use in addition to yours. This is a great option to use when you want to create different style of images. For example I used a sketch LoRA for this one:

And a photo session one for this one:

While definitely not all the images are good, some have weird accessories, some have scratches where the model got confused what to do, etc, most of them are fine and generated in no time. The LoRA can be deployed on Replicate and used as API calls for your AI applications, presentations content, blog posts. Have fun generating your own images in all kind of styles and landscapes!

The post Flux training on Replicate appeared first on it.ivdimova.com.

Why Playwright?

For those unfamiliar, Playwright is a robust browser automation library developed by Microsoft for reliable end-to-end testing. Playwright supports multiple browsers, including Chromium, Firefox, and WebKit, making it a versatile choice for developers. It’s also used for the browser-based tests in WordPress core.

Key Takeaways

The session started with an introduction to the basics of Playwright, including setting up the environment and writing your first script. The talk demoed how to initiate browser instances, navigate through pages, and simulate user inputs like clicks and form submissions.

One of the highlights of the meetup was learning about Playwright’s capabilities for handling asynchronous events and its rich set of APIs for asserting conditions in a browser context. This is particularly useful for WordPress developers who need to test dynamic content and interactions driven by JavaScript.

As always, the interactive Q&A session sparked engaging discussions on best practices and shared challenges. Experienced developers and newcomers alike exchanged tips on everything from organizing test suites to advanced scenarios.

Looking Forward

The Porto WordPress Meetup continues to be a valuable platform for local WordPress developers to share knowledge and collaborate on improving their development practices. The introduction to Playwright has equipped many attendees with new tools to enhance the quality of their projects and has sparked interest in further exploration of automated testing technologies. Excited to discover what the next topics will be in 2025!

The post Exploring Playwright at the Latest Porto WordPress Meetup appeared first on it.ivdimova.com.

Uros Tasic showed us how to code and test with WordPress Playground – very handy platform that allows you to develop, test and explore ideas within WordPress with one click. For many years setting up local installs and trying to mimicic the real server environment in order to test new releases was a common struggle for many developers. Using Playground we can setup quick installs and spend more time to actually develop and test the project.

Shady Sharaf made a great introduction on using XDebug to investigate errors, complimented by showcases for JavaScript debugging and flamegraphs for performance tracking. While XDebug has been around for a very long time, setup and mapping is still an issue for many developers. The talk focused on showcasing how to setup the environment, explanation of the functionality and the different ways to debug issues plus remote debugging!

Sarah Norris shared her tips and tricks for beginners that are interested in contributing to Gutenberg in WordPress Core. For many newbies its quite scary and confusing how to select a ticket to contribute to. There are a lot of issues, comments and workflow to read and familiarise with. Getting smaller, clear to you tickets, asking for clarification and getting to know the process and the testing approach were amongst the ideas that the talk suggested.

And last but not least Micha? Czapli?ski introduced us to the way to use the Interactivity API to streamline WordPress front-end development. Interactivity API is included in WordPress core since version 6.5 and introduces an easier and more modern approach for developers to add interactions to the front end of their blocks. Examples for interactivity blocks in the core Michal mentioned are query loop block with enhanced pagination and the image block with on click option that opens a larger view for the image. Later I realised he did a similar session at WordCamp Europe 2024, so if you are interested in tips for using Interactivity API, here it is: https://europe.wordcamp.org/2024/session/interactivity-api-the-new-standard-way-to-build-modern-wordpress-frontends/

In conclusion, there is definitely a need for more development oriented events like this, smaller and with more focus. I got a lot of useful ideas, had the opportunity to meet new people and say hi to old friends. So much for this year and to many exciting events in 2025!

P.S. As I mentioned exiting events next year, we just launched the tickets for WordCamp Europe 2025 in Basel, Switzerland!

The post WordPress Day for Developers – Lisbon appeared first on it.ivdimova.com.

Luis Martin-Santos from Cabify gave a great talk about “Estimates as probabilities”, illustrated with a nice comic story that was handed to the attendees. The idea of giving the estimate a value of how sure we are this estimate will be met, is definitely useful in many projects where the estimates are hard or impossible to make.

Another interesting talk was “Level up the whole party, not just the hero” by Denise Yu, where she described how by helping everyone in the team improve their skills, we move forward a way faster. She mentioned some key tools for the team and personal leveling up – a proper career matrix, employee skill survey and gap analysis, and of course a good professional development plan. She also mentioned an interesting resource for the career matrix, which many organisations struggle with – https://progression.fyi/ where you can find resources from lead companies in many sectors. There is always a room for improvement and following these steps, we can give our teams better visualisation of the next steps in their knowledge and career development.

My absolutely favourite talk was “Ice, confusion, and the 38,000ft crash” by Nickolas Means. As much as I like technical talks, the ones that are related to a real life story are always more engaging and this one was definitely a great one, as horrifying the story was. In a very short summary Nickolas described how a plane crash was caused by relying too much on automation. With the AI tools taking so much attention lately, we start relying on them more and more. There is a valid concern that at some point this will lead to developers that mostly write AI prompts, but don’t understand the errors and misunderstandings that it can lead to. Have you had a case when an AI coding tool understood you completely wrong? Guess we all had. Imagine what will happen if we didn’t know what to look for and how to correct it. In conclusion it’s a great tool, but still a tool, that needs a human brain to work it out.

Except the talks, LeadDev had several interesting activities, workshops, AMA sessions and table talks. I enjoyed a lot the CircleCI workshop “Learning from failure: How to adapt your leadership style to lead effectively through uncertainty”. Initially I thought that 80 minutes is a bit too much, but it was so engaging that felt short. We did groups by 4 discussing different problems like implementing engineering manager role in teams, working with various teams at the same time and leading a change in an organisation. Definitely a great experience.

And last but not least, I have to mention the AMA sessions – these were really interesting! I attended the ones on topic of engineering managers, principal engineers and staff engineers and they were all engaging and fun. It was very helpful to hear how different companies approach these roles and learn more about the experience the speakers had at their career path.

So that’s a wrap! While this was my first LeadDev, it definitely won’t be the last and I hope to learn more about leadership progression next year!

The post LeadDev Berlin :: impressions (); appeared first on it.ivdimova.com.

Let’s go through creating a simple Gradio app and deploying to share it.

Gradio provides a quick way to create demos with input and output fields that could be media, audio, text, etc.

import gradio as gr

def greet(name, intensity):
    return "Hello, " + name + "!" * int(intensity)

demo = gr.Interface(
    fn=greet,
    inputs=["text"],
    outputs=["text"],
)

demo.launch()

This is a quick example of a text input and output in Gradio. Setting up

demo.launch(share=True)

will generate proxy/tunnel through the Gradio servers and while the app will still run on your machine, you will get a link, available to share for 72hours.

Now what’s left is to build the actual functionality in the Gradio app. First we need to pick a model for this app, which is quite overwhelming with the number of available models lately. As probably the biggest area for open source models, Hugging Face is the natural place to look at. Choose the model menu and select from the criteria in the left hand panel – my choice for this example is simple – text2text generation, open source license. Then sort the results by trending or by most downloaded and check the model cards. I needed something, that I can run locally, but still gives good results, so I choose https://huggingface.co/TinyLlama/TinyLlama-1.1B-Chat-v1.0

After choosing the right model, click on the <Use in Transformers> link on the right, to see an example how to load it. Here is my very basic example for the purposes of this blog post:

def travel(country):
   messages = [
    {
        "role": "system",
        "content": "You are a friendly chatbot who loves to help people find the perfect vacation spot. You can answer questions about popular vacation spots in different countries.",
    },
    {"role": "user", "content": f"Where can I go on vacation from {country}?"},
	]
   prompt = pipe.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
   outputs = pipe(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)

   output_text = outputs[0]['generated_text']
   assistant_message_start = output_text.find('<|assistant|>') + len('<|assistant|>')
   assistant_message = output_text[assistant_message_start:].strip()

   return assistant_message

And now all we need to do is to load this function in the Gradio app.

import gradio as gr

demo = gr.Interface(
    fn=travel,
    inputs=["text"],
    outputs=["text"],
)

demo.launch()

And here, you have a simple app, that you can ask about travel destination ideas.

If you want to get a permanent demo for sharing with the external world, Hugging Face Spaces are a great option. Just select a free space (you have to be very mindful about the model size tho as the free option is quite limited in resources), clone the repo locally, add your app files and deploy to Spaces.

And just like that, we have our own LLM powered app. What are you building with AI these days and what’s your favourite playground? Let me know in the comments.

The post Playing with Gradio appeared first on it.ivdimova.com.

Listing my few favourite take aways below: 

Conditional configs:

includeIf

adds conditional configuration for different projects

git blame -L

Performs git blame on specific lines of the file, making it easier to perform checks

git log -L

Same, but with git log – shows the history of a specific the function or lines of code.

git blame -w

Performs git blame, ignoring the white space.

git blame -w -C -C -C

Blame looking in all commits, ignoring the white space – useful in refactoring and moving code between files 

git reflog

See the reference logs – easier way to track the merges and branches references.

git config —global rerere.enabled true

Reuse Recorded Resolution – remembers how you fix merge conflicts and fixes automatically 

git maintenance start

Adds config for a cron job to do maintenance, speed things up on monorepos and big repositories in general, by performing hourly checks and fetch.

Monorepo

git sparse-checkout

Gets only the needed directories from a mono repo, but makes it look like you have all of them locally.

These are also described in a way more detail in his new project blog – https://blog.gitbutler.com/ , take a look and pick your favourite! 

The post Git tricks appeared first on it.ivdimova.com.

First I want to thank to all the organisers, this was the biggest and, in my opinion, the most professionally organised WordCamp I have ever been to! As a speaker I had a wonderful experience – a separate room where we could prepare for our talks, help screens to not look back the main screen for the slides, great MCs and much more. The event was huge with more than 2000 attendees, volunteers and speakers, so it will be very hard to summarise it, but I will try to just highlight what I liked the most.

The WordPress core lead Andrew Nacin had an awesome talk about working with legacy projects. I personally was leading the Crowd Favorite Ongoing Clients Support team for a while and had lots of the issues mentioned in the talk, I really hope it will be soon on WordPress TV!

Mike Schroder shared his experience about how the decisions are made at WordPress core, so everyone who wants to contribute and get involved in the process can see how it goes.

Sonja Leix had a very inspiring talk about the impostor syndrome, which I recommend to anyone who is wondering if should apply to speak at WordCamps or any other event – you should! Post and slides here – http://sonjaleix.com/blog/community/impostor-syndrome/.

And while on this topic I want to personally thank to Jeremy Felt , who shared with us, the speakers, this very inspiring TED talk about body language – it helped me a lot preparing for my own talk! He also presented on Multisite, slides here.

Also our CEO Karim Marucchi had a great talk sharing his experience how to deal with different cultures.

And my personal favourite, and I believe to many others too – Helen Hou-Sandi and her incredibly inspiring talk about parallels between music and code! As a woman in tech and a person in love with music, I admire her and loved both the piano performance and the talk, hope it will be available online soon so I can watch it again. Code really is poetry!

Last but not least – I presented on WordPress developers tools that can help us automate our daily workflow and produce more reliable, clean and consistent code. My slides can be found here and I will work on a longer blog post with all tutorials and articles that can help you learn these tools and adopt them in your development projects.

It was an amazing event and I was honored to be there and share my experience! Thanks again to everyone involved in the organisation! See you next year in Paris!

The post WordCamp Europe 2016 appeared first on it.ivdimova.com.

And if for some reason you are still not convinced how incredible amazing WordCamps are here is a video from WordCamp Europe 2013, which I had chance to visit. Watch the video and see for yourself!

The post WordCamp Sofia 2013 appeared first on it.ivdimova.com.