FLOSS Project Planets

Working as a Drupal contractor can be rewarding and fulfilling, but it also comes with its own set of challenges. In this article, we'll explore 6 tips for boosting productivity and success as an independent contractor. From setting clear goals and priorities to staying organized and keeping your skills up-to-date, these tips can help you be more efficient and effective in your work. We'll also discuss the importance of networking and building relationships, as well as how to negotiate fair and reasonable rates for your services. By following these tips, you can set yourself up for success and enjoy a fulfilling career as an independent Drupal contractor.

The question we want to answer in this blog post is whether Drupal is still the leading CMS platform in 2022 and beyond. If you have been thinking of trying out Drupal, this article will help you decide whether it is still worth it in 2022. Let’s jump right in!

I have been attending Drupal Dev Days for the fifth time and I have to say that this year’s event was as great as the other ones. The tech talks were really interesting and I learned a lot about new trends in the industry. In this article my highlights.

We are working on porting Feeds to Drupal 8 today at the Global Sprints weekend in Amsterdam. We would like to know from you how you use these and similar import/export modules and what functionality you like but still miss in Drupal 8.

As always the Drupal Association puts videe-recording of most sessions on DrupalCon Youtube.
That is also true for the now ongoing DrupalCon New Orleans 2016.
An excellent option for learning and understanding Drupal. (and following the event!)

Drupal 8 is better than Drupal 7. Data-modelling, performance, multi-language. It feels so much more robust this day. More functionality is in-core and fully tested.
In a conceptual way, Drupal 8 is not so different from Drupal 7. The Administration-UI’s are the same and you probably will also use the same modules for a project. Site builders will feel really comfortable.
All-in-all I am getting excited about Drupal 8!

More than 125+ sessions from last week's Drupalcon in Barcelona are on Youtube:

https://www.youtube.com/user/DrupalAssociation/videos

Posted by the Drupal Association.

Hope you can learn from it too!

One little Drupal community secret: the main-event of a DrupalCon might be sprinting... Right now (Saturday 26th Sep) the Drupal community is pushing hard on the first next-gen CMS that will have stable releases early 2016.

This article contains a detailed instruction on how to setup the Entity Translation module for Drupal 7 websites.
Entity Translation is part of Drupal 8 core and its approach is to translate fields instead of full nodes/entities.

Goal of this tutorial is to set up a multilingual website that can be navigated in multiple languages by visitors and to enable the content to be easily manageable by editors / cms administrators.
To get multilingual right, it’s critical that you configure your content-types and fields with care and precision and upfront, because if content is already in your database it is almost impossible to change these configurations.
So let's go.

Recently I was building a Drupal site with Display Suite, Entity Reference and Bootstrap. In this blog I want to share why that combination and some tricks I used to get a great frontend and editor-UX.

This is a bug fix and minor feature release over INN 2.7.1, and the upgrade should be painless. You can download the new release from ISC or my personal INN pages. The latter also has links to the full changelog and the other INN documentation.

For the full list of changes, see the INN 2.7.2 NEWS file.

As always, thanks to Julien ÉLIE for preparing this release and doing most of the maintenance work on INN!

Tellico 3.5.5 is available, with a few important fixes.

Improvements and Bug Fixes

• Fixed the XSLT file loading to work correctly with libxml2 >= 2.13 (Bug 488707).
• Fixed bug for showing entries with large content (Bug 487079).
• Improved the SRU fetcher to allow user-defined search indices (Bug 488931).

KWin had a very long standing bug report about bad performance of the Wayland session on older Intel integrated graphics. There have been many investigations into what’s causing this, with a lot of more specific performance issues being found and fixed, but none of them managed to fully fix the issue… until now.

The source of the problem

Understanding the issue requires some minimal understanding about how displays work. My earlier post about gaming on Wayland goes into more depth about them and the different presentation modes, but the TL;DR is that most displays today require frames to be sent to it in fixed intervals if you want them to be shown without tearing artifacts.

With the vast majority of displays, that interval is 16.67ms. In order to show everything as smooth as possible, the compositor thus has to render a new frame every 16.67ms as well; it must not miss a single deadline or the user will see stutter as some frames are shown twice and others are skipped.

This problem is not unique to Intel of course, when the deadline is missed, that causes the same stutter on every system. It’s just an often reported issue on old Intel processors because they’re used a lot, because both CPUs and GPUs in them are pretty slow, and laptop manufacturers too often paired them with high resolution screens, requiring the GPU to render for a long time each frame.

How KWin deals with this deadline

In the past, KWin would just start compositing immediately once the last frame was presented, to have as much time as possible for rendering; this worked pretty well but meant that it almost always rendered too early. On desktop GPUs, compositing can take as little as a few hundred microseconds; if we start compositing 16ms before the deadline, that means we’re also unnecessarily increasing latency by roughly 16ms, which makes the system feel less responsive.

For KWin 5.21, Vlad Zahorodnii implemented a scheduling mechanism to do this better: Instead of assuming we always need the whole frame for rendering, KWin measures how long rendering takes and could start compositing closer to the deadline, which reduced latency. However, this strategy could still not get very close to the deadline by default, because it only measured how long rendering took on the CPU, but not how long it took on the GPU.

For KWin 6.0, I implemented the missing part, recording GPU render times. This meant that we could reduce latency more, without causing stutter… Or at least that was the idea. It turns out, render times are very volatile at times; KWin’s rendering can be delayed by other apps using the CPU and GPU, by the hardware changing power management states, by additional windows opening, by KWin effects starting to render something heavy, by input events taking CPU time, and so on.

As a result, taking a simple average of recent render times wasn’t enough, and even taking the maximum wasn’t good enough to prevent all the noticeable stutter. Instead, KWin now analyzes past render times for how volatile they are, and starts compositing much earlier if they’re volatile, and only moves closer to the deadline when render times are stable and predictable. This will likely be tweaked a few more times as I can collect more render time data from different PCs and optimize that algorithm with it, but so far it works pretty well, and gets us the best of both worlds: High latency when necessary to prevent stutter, and low latency when possible.

So, with these old Intel processors, KWin should now detect that rendering takes long and render times are not very stable, and start rendering as early as possible, and that should fix everything, right? Unfortunately, that’s not the whole story.

Old Intel processors are just too damn slow!

On these old processors, especially when paired with a 4k screen, rendering doesn’t just take long, it often takes too long for a frame to be completed after 16.67ms! All the previous improvements were useful, but can’t make the hardware faster.

In the very beginning of the post I hinted that this is a Wayland only problem though, so what’s going on on Xorg? kwin_x11 has a trick that makes this problem less severe: On the start of each refresh cycle, it starts rendering a frame, even if the last frame isn’t done rendering yet. This is called “triple buffering”1 because it uses up to three buffers at the same time (two for rendering, one for displaying) and it has two big benefits:

• while the GPU is still working on the last frame, the CPU can already prepare rendering commands for next one. As long as both CPU and GPU individually take less than 16.67ms, you can still get one image rendered for each frame the display can present
• because more frames are being rendered, the driver may increase CPU and GPU clock speeds, which makes rendering faster and might allow for hitting the full refresh rate

However, it also has some caveats:

• it increases latency in general, as rendering is started earlier than necessary
• when rendering takes more than one refresh duration, latency is increased by a whole refresh duration - even if it would only need a single millisecond more for rendering
• to avoid increasing latency for dedicated GPUs, it’s only active on Intel GPUs and never used elsewhere
• it’s active even on Intel GPUs that have good enough performance to not need it
• when the driver increases GPU clocks because of triple buffering, that may be enough for rendering to be fast enough to not need triple buffering anymore… which means the GPU clocks will reduce again, and frames will be dropped until triple buffering is active again, and that repeats in a cycle. This can, in some situations (like video playback), be more noticeable than a reduced but constant refresh rate.

The goal then was to implement a form of triple buffering that would come with the same benefits, without also having the same shortcomings. First, a few things needed to be patched up to allow for triple buffering to work.

Fixing prerequisites

The DRM/KMS kernel API currently only allows a single frame to be queued for presentation at a time. When you submit a frame to the kernel, you have to wait until it’s done rendering and shown on the screen, before you’re allowed to commit the next frame - but for triple buffering we need to queue two frames. Luckily I had already implemented a queue for other functionality with a drm commit thread (check out my previous post about cursor updates for details), so this one was mostly taken care of already and only needed minor changes.

The queue wasn’t good enough yet though. If KWin’s render time prediction is too pessimistic and it starts rendering much earlier than necessary, it could end up rendering two frames that are meant for consecutive refresh cycles, and complete rendering both during the same refresh cycle… which means that GPU power is wasted. Worse, as the refresh rate of apps is coupled to KWin’s, apps would try to render twice as fast too! To fix that, frames are now simply delayed until the time they’re intended to be displayed.

In order to figure out how long compositing takes on the GPU, KWin uses OpenGL query objects. These are quite useful, but they have three issues for triple buffering:

• query objects only hold a single result. If you start two queries, the last one gets dropped
• if you query a timestamp for commands that haven’t finished executing yet, OpenGL will do a blocking wait until that’s done
• they’re bound to an OpenGL context, which especially complicates things with multiple GPUs

To avoid the last problem, I did a bunch of OpenGL refactors that removed unnecessary global state from OpenGL code, and encapsulated what was left in OpenGL context objects. Render time queries in KWin now store a reference to the OpenGL context object they were created with and handle the context switching for fetching the result themselves, so code using them doesn’t have to care a lot about OpenGL anymore. With that done, the other two issues were fixed by simply creating a new query for each frame, which gets queried after the frame is done rendering, and never gets reused.

Actually implementing triple buffering

After these prerequisites were taken care of, I extended the existing infrastructure for frame tracking, OutputFrame objects, to encapsulate more properties of presentation requests and handle render time tracking as well as presentation feedback directly. With all information and feedback for each frame being tracked in a single object, a lot of presentation logic was simplified and allowing multiple pending frames ended up being a relatively simple change in the drm backend.

To make use of that capability, I extended the render scheduling logic to allow render times of up to two frames. It computes a target presentation timestamp by calculating how many refresh cycles have gone by since the last presented frame and how many refresh cycles rendering will take. If there’s already a frame pending, it just ensures that the refresh cycle after that is targeted instead of the same one… and that’s almost it.

Remember how I wrote that displays refresh in a fixed time interval? Well, it’s not that simple after all. Timings can fluctuate quite a bit, and that could make KWin sometimes schedule two frames for the same refresh cycle, just for the older one to get dropped again and be a complete waste of energy and even cause stutter. As a fix, when the last frame completes and provides a more accurate timestamp about when the next refresh cycle begins, KWin now reschedules rendering to match it.

This is the state of things in the 6.1.0 release; since then issues on a few systems were reported and more adjustments may still be added - in particular, some sort of hysteresis to not make KWin switch between double- and triple buffering too often.

The result

With all those changes implemented in Plasma 6.1, triple buffering on Wayland

• is only active if KWin predicts rendering to take longer than a refresh cycle
• doesn’t add more latency than necessary even while triple buffering is active, at least as long as render time prediction is decent
• works independently of what GPU you have

In practice, on my desktop PC with a dedicated GPU, triple buffering is effectively never active, and latency is the same as before. On my AMD laptop it’s usually off as well, only kicking in once in a while… But on some older Intel laptops with high resolution screens, it’s always active and I’ve been told it’s like having a brand new laptop - KWin goes from doing stuttery 30-40fps to a solid 60fps.

It’s not just old or slow processors that benefit though, I also tested this on a laptop with an integrated Intel and a dedicated NVidia GPU. With an external display connected to the NVidia GPU, due to some issues in the NVidia driver, multi gpu copies are quite slow, and without triple buffering, the external monitor was limited to 60fps. Triple buffering can’t do magic, but KWin now at least reaches around 100-120fps on that setup, which is likely the best that can be done until the driver issue is resolved and feels a lot smoother already.

1. Keep in mind that “triple buffering” means a few different things to different people and in different contexts. I won’t go deeper into that mess here; just be aware that it’s a loaded term. ↩

Tuesday, 25 June 2024. Today KDE releases a bugfix update to KDE Plasma 6, versioned 6.1.1.

Plasma 6.1 was released in June 2024 with many feature refinements and new modules to complete the desktop experience.

This release adds a week's worth of new translations and fixes from KDE's contributors. The bugfixes are typically small but important and include:

• KScreenLocker Greeter: Fix Shader Wallpaper plugin and possibly others. Commit.
• Increase minimum plasma wayland protocols version to 1.13. Commit.
• Use snap:// URLs rather than appstream:// ones on snap only distros. Commit.

View full changelog

Kommit 1.6.0 is a feature and bugfix release of our Git repo app which now builds with Q 5 or 6.

Improvements:

• build without kdbusaddons on windows
• Add flatpak support
• Fix show date (using QLocale for it)
• Fix mem leak
• Reactivate open file in external apps in qt6
• Add zoom support in Report Chart Widget
• Replace a QTableWidget by QTreeWidget in report page
• Fix crash when we didn't open git repository
• Fix load style/icon on windows (KF >= 6.3)
• Implement a gravatar cache
• Fix i18n

URL: https://download.kde.org/stable/kommit
Source: kommit-1.6.0.tar.xz
SHA256: 4091126316ab0cd2d4a131facd3cd8fc8c659f348103b852db8b6d1fd4f164e2
Signed by: E0A3EB202F8E57528E13E72FD7574483BB57B18D Jonathan Esk-Riddell jr@jriddell.org
https://jriddell.org/esk-riddell.gpg

GNU Parallel 20240622 ('34 counts') has been released. It is available for download at: lbry://@GnuParallel:4

Quote of the month:

  The most glorious 15,000 lines of Perl ever written.
    -- @nibblrrr7124@YouTube
 
New in this release:

• Bug fixes and man page updates.

News about GNU Parallel:

• Howto - Parallel: lanciare comandi in simultanea https://github.com/linuxhubit/linuxhub.it/blob/main/_posts/2024-06-14-howto-parallel-per-lanciare-comandi-in-simultanea.md
• Implementing Concurrency in Shell Scripts https://dev.to/siddhantkcode/implementing-concurrency-in-shell-scripts-521o

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

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

About GNU Parallel

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

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

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

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

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

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

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

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

You can install GNU Parallel in just 10 seconds with:

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

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

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

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

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

If you like GNU Parallel:

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

If you use programs that use GNU Parallel for research:

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

If GNU Parallel saves you money:

• (Have your company) donate to FSF https://my.fsf.org/donate/

About GNU SQL

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

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

When using GNU SQL for a publication please cite:

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

About GNU Niceload

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

The first month of the coding period of GSoC has already passed! Since the last update, I added Python support for the remaining classes of KWidgetsAddons. It was only recently when I discovered that apart from the C++ classes, the libraries also have namespaces which I didn’t even know about. So it turned out that it wasn’t actually completed. But anyway, there were only a few so that is now done. I also added support to automatically build a Python wheel for the bindings.

Last week I improved some Python demos and added bindings for KCoreAddons. That was quicker than I expected, so I might end up adding support for 5-7 more libraries that it was initially planned for. Here’s a list of the libraries that I plan to add during the rest of the summer:

• KI18n
• KGuiAddons
• KNotifications
• KUnitConversion
• KXMLGui

Today we are talking about DDEV, The DDEV Community, and It’s Future Sustainability with guest Randy Fay and Andrew Berry. We’ll also cover DDEV Drupal Contrib as our module of the week.

For show notes visit: www.talkingDrupal.com/456

Topics

• What is DDEV
• In March you posted the DDEV Project Plan for 2024, what is the contributor training initiative
• DDEV has grown rapidly over the past few years, what do you attribute that to
• You seem to be the face of DDEV, who else is involved
• How is DDEV funded
• What happens when you retire
• Does the DDEV Foundation have employees
• What is DDEV coded in
• What is your favorite feature of DDEV
• What is next
• How can people get involved

Resources

• DDEV Project 2024 Plans
• DDEV Contributor Live Training
• Scheduling and signup
• DDEV Discord
• Nerdsniping XKCD Comic
• Level one learning xz utils

Guests

Andrew Berry - deviantintegral

Hosts

Nic Laflin - nLighteneddevelopment.com nicxvan John Picozzi - epam.com johnpicozzi Randy Fay - rfay

MOTW Correspondent

Martin Anderson-Clutz - mandclu.com mandclu

• Brief description:
  • Have you ever wanted a local DDEV environment optimized for working on a Drupal contrib project? There’s a DDEV add-on for that.
• Module name/project name:
  • DDEV Drupal Contrib
• Brief history
  • How old: created in Apr 2023 by Moshe Weitzman, a Drupal core maintainer, and according to his resume the first American to contribute to Drupal
  • Versions available: 1.0.0-rc8
• Maintainership
  • Actively maintained
  • Test coverage
  • Documentation - Lengthy README
  • Number of open issues: 2 open issues, 1 of which is a bug
• Module features and usage
  • The add-on adds two ddev commands to help during setup:
  • ddev poser creates a temporary composer.contrib.json, adding drupal/core-recommended as a dev dependency. It also runs composer install and yarn install so that all dependencies are available
  • The additional ddev symlink-project command adds symlinks from your project files to an expected path within the custom modules directory of the installed version of Drupal
  • Once it’s set up, you can easily run tests locally exactly the way they will be run in GitlabCI. It’s also even easier to apply any of the automatic fixes that are available, for example by running ddev phpcbf or ddev eslint with the –fix flag
  • You can also commit the generated .ddev directory inside your project, to make it easy for other contributors to use the same tools
  • I will note that after running ddev poser I got errors trying to use composer to add any other projects to the local environment, for example to use admin toolbar for manual testing
  • That said, this is another great example of how the set of Drupal developer tools is always improving, and also illustrates to the power of DDEV’s add-ons

Dear Readers,

Marketing in the open-source community often grapples with a unique set of perceptions and challenges. Traditionally, the open-source ethos values transparency, community collaboration, and accessibility, sometimes viewing commercial activities with scepticism. However, effective marketing is not antithetical to open-source values; it can amplify the reach and impact of projects like Drupal. By embracing strategic marketing, open-source projects can attract a wider audience, ensuring their tools and innovations benefit more users and contributors. This expanded reach helps sustain the project's growth and ensures it remains competitive in a rapidly evolving technological landscape.

The importance of marketing for open-source projects like Drupal cannot be overstated. It is not merely about promoting a product but telling a compelling story that resonates with potential users and contributors. Shawn Perritt, the Brand and Creative Director of Acquia, who is leading the brand refresh, believes that every great idea should live at the intersection of creativity and commerce.

According to Suzanne Dergacheva, the lead of the Promote Drupal team, strategic rebranding and marketing efforts help to refresh Drupal’s image, making it more relatable and appealing. These efforts ensure that Drupal continues to attract diverse contributors who bring fresh perspectives and innovations. The right marketing strategies help articulate Drupal's value proposition, highlighting its robustness, flexibility, and vibrant community, driving adoption and engagement.

The recent Drupal brand refresh, discussed at the Drupal Branding Panel session at DrupalCon Portland 2024, exemplifies how marketing can reinvigorate an open-source project. The rebranding initiative introduces new design elements and a refreshed DrupalCon logo, better capturing the spirit of open source and Drupal’s innovative edge without losing its core values. This strategic rebranding is not just a visual update; it represents a concerted effort to position Drupal as a leading digital experience platform, ensuring its relevance and appeal in the market.

With that, let's move on to the important stories of last week.

Last week, Suzanne Dergacheva, co-founder and strategist at Evolving Web, also the lead of the Promote Drupal Initiative and a member of the Drupal Branding Panel, spoke with The DropTimes. In this interview, Suzanne discusses the ongoing Drupal rebranding efforts. She shares insights into the key factors that prompted the rebranding, the collaborative contributions from the community, and the challenges faced in a competitive landscape. Suzanne also highlights how the new branding strategy aligns with Drupal’s commitment to the open web and the significance of community feedback in shaping the final decisions. This conversation provides a comprehensive overview of the exciting changes underway for Drupal, complementing our earlier interview with Shawn Perritt, about the brand refresh.

Another highlight from last week is that Kazima Abbas, sub-editor of The DropTimes, had the chance to connect with Christina Lockhart, Digital Marketing Manager with the Drupal Association. The interview explores her role in promoting Drupal through digital marketing, her efforts to empower women in the tech community, and her initiatives to support women within the Drupal ecosystem. Christina also shares her insights on ensuring equal access to leadership roles and the potential impact of emerging trends like AI on Drupal's future.

The 20thDrupalJam was celebrated in Utrecht, the Netherlands, with over 330 participants in attendance. This year's event was especially festive, highlighted by a personal keynote from Dries Buytaert. The day featured a variety of engaging presentations, insightful workshops, and stimulating discussions and panels. Esmeralda Braad-Tijhoff shared the key highlights.

The Drupal AI Meetup debuted last week, marking the beginning of a series of quarterly meetups dedicated to exploring the intersection of Drupal and artificial intelligence. This new initiative aims to bring together enthusiasts and experts to delve into the dynamic fusion of these fields, writes Nico Grienauer, the event organiser.

Drupal 10.3 is available now! Drupal has announced the release of Drupal 10.3, the third and final feature release for Drupal 10. This update introduces several new features, including an experimental Navigation user interface, stable Workspaces functionality, and Single-Directory Components support, among others.

A significant development has emerged in the Drupal ecosystem with the announcement of a new AI Initiative module. Reported by Jamie Abrahams from FreelyGive and Marcus Johansson from OSK Berlin, this module aims to consolidate the best features of various AI modules into a comprehensive set of foundational tools for all AI applications in Drupal.

Last week, Drupal introduced a new community Frontend Bundler Initiative to address the lack of a standard method for installing JavaScript dependencies in Drupal. The initiative aims to create a unified approach to managing these dependencies, drawing on discussions and collaborations with key contributors like Lee Rowlands and Théodore Biadala. Additionally, Jürgen Haas announced the release of ECA 2.0.0 for Drupal 10.3 and 11, featuring significant improvements such as dynamic event subscriptions, 74 new plugins, and a comprehensive code clean-up. 

Aten Group is hosting a webinar titled "Migrate with Might: Tips and Tricks for Drupal's Migration Tools" on June 26, 2024, at 2 PM EDT. Joel Steidl, VP of Engineering at Aten, will lead the session. The webinar aims to explore Drupal's versatile migration system, which is instrumental in data integration tasks. The DropTimes has released a complete list of Drupal events for this week. Find the guide here.

In interesting news, Lauri Timmanee has joined the DrupalCamp Spain 2024 as the featured speaker. The event has also extended its deadline for papers until June 30, 2024, and has opened the call for training proposals. Also, Submissions for the 2024 Splash Awards Deutschland und Österreich, honouring outstanding Drupal projects in Germany and Austria, are now open until July 31.

PHPCamp 2024, held on June 8th, was a resounding success. The event stood out with its relaxed atmosphere, where knowledge-sharing, impromptu demos and collaborative problem-solving took centre stage. 

amazee.io has partnered with ANNAI Inc. to bring its open-source Platform-as-a-Service (PaaS) to Japan. The company aims to empower local businesses with scalable, flexible application delivery and hosting solutions.

We acknowledge that there are more stories to share. However, due to selection constraints, we must pause further exploration for now.

To get timely updates, follow us on LinkedIn, Twitter and Facebook. Also, join us on Drupal Slack at #thedroptimes.

Thank you,
Sincerely
Alka Elizabeth
Sub-editor, The DropTimes.

Most software projects benefit from having a piece of documentation that provides a quick start guide for setting up, using, and contributing to the project. This is especially true in open-source projects where you typically want to attract users and contributors. This type of document is commonly known as a README file, and you should add one to each Python project you create.

In this tutorial, you’ll learn:

• What a README file is
• How to organize a README file
• What document format to use for README files
• How to prepare a README file for platforms like PyPI and GitHub
• What tools and templates to use to create README files

You won’t need special knowledge to read through this tutorial. However, to start creating your own README files, you should familiarize yourself with markup languages, such as Markdown and reStructuredText.

Get Your Template: Click here to download the free template you can use to create your own great README files.

Take the Quiz: Test your knowledge with our interactive “Creating Great README Files for Your Python Projects” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Creating Great README Files for Your Python Projects

Take this quiz to test your understanding of how a great README file can make your Python project stand out and how to create your own README files.

What Is a README File?

A README file is a document that you typically add to the root directory of a software project. It’s often a short guide that provides essential information about the project. The README file aims to help users and developers understand the project’s purpose, how to use it, and how to contribute to it. It’s also a way to communicate with potential users, collaborators, and contributors.

README files are typically plain text files that are the most visible piece of documentation and often the landing page for many software projects, including open-source projects.

In most cases, the file name is written in uppercase letters to draw the user’s attention and ensure it’s the first thing they read.

A README should contain only the necessary information for users, collaborators, and developers to get started using and contributing to your project. For more extended documentation, wikis or dedicated documentation pages are more appropriate and recommended.

Why Do You Need a README in Your Python Projects?

README files have a long history in free and open-source software. The GNU Coding Standards encourage you to include a README to provide a general overview of the package’s contents. However, this type of file isn’t limited to free and open-source projects. You can add a README to any project you like.

Why should you spend time writing a README file for your Python projects? Here are a few general reasons:

• README files are kind of a standard in the software industry.
• The README file is frequently the first thing your users will notice or search for when they find your project.
• A good README file helps your project stand out from other projects.
• A high-quality README file differentiates a good project from a bad one.
• README files are often displayed as the project’s landing page on software development platforms like GitHub and GitLab.

From a more specialized point of view, a good README file can help you:

• Introduce the project by providing an overview of what the project is about, its purpose, and its main features.
• Provide guidance by offering instructions on how to set up the project for use and contributions.
• Attract contributors by providing clear guidelines on how to contribute to the project.
• Provide documentation by working as the primary source of documentation for the project.
• Supply support and contact Information by providing details on how to get help or contact the project maintainers.
• Include license information by specifying the terms for using and contributing to the project.

These are just a few of the benefits of adding a README file to your Python projects. So, what do you think? Is it worth it to add them?

What Is the Usual Structure of a Great README File?

First, you should know that there isn’t one right way to structure a high-quality README file. In practice, the content and sections you include in this file will depend on your specific project. However, you’ll find that most README files have common sections, such as the project’s name, the instructions on how to set up and use the project, guidelines for contributing to the project, and similar topics.

In the following sections, you’ll learn about the most commonly used sections in README files and their content.

Common Sections in Great README Files

Before discussing how to organize a README file in a well-structured document with pertinent sections, you’ll briefly consider the general content that most README files contain. To approach this topic for a given Python project, you try to answer the following questions:

Read the full article at https://realpython.com/readme-python-project/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]