Feeds
Niels de Feyter: Watch Drupalcon Barcelona 2015 sessions on Youtube
https://www.youtube.com/user/DrupalAssociation/videos
Posted by the Drupal Association.
Hope you can learn from it too!
Niels de Feyter: Watch Drupalcon Barcelona 2015 sprinting on drupal.org
Niels de Feyter: Setup Entity Translation the right way
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.
Niels de Feyter: Why I use Display Suite, Entity Reference and Bootstrap
Russ Allbery: INN 2.7.2
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 Released
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).
Fixing KWin’s performance on old hardware
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 problemUnderstanding 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 deadlineIn 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 prerequisitesThe 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 bufferingAfter 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 resultWith 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.
-
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. ↩
KDE Plasma 6.1.1, Bugfix Release for June
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.
Kommit 1.6.0
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
Open Source AI Definition – Weekly update June 24
Following @stefano’s publication regarding why the OSI considers training data to be “optional” under the checklist in Open Source AI Definition, the debate has continued. Here are the main points:
- Preferred Form of Modification
- @hartmans states finding an agreement on the meaning of “preferred form of modification” depends on the user’s objectives. The disagreement may stem from different priorities in ranking the freedoms associated with open source AI, though they emphasize prioritizing model weights for practical modifications. He suggested that data information could be more beneficial than raw data for understanding models and urged flexibility in AI definitions.
- @shujisado highlighted that training data for machine learning models is a preferred form of modification but questioned if it is the most preferred. He further emphasized the need for a flexible definition for preferred forms of modification in AI.
- @quaid supported the idea of conducting controlled experiments to determine if data information alone is sufficient to recreate AI models accurately. Suggested practical steps for testing the effectiveness of data information and encouraged community participation in such experiments.
- @jberkus raised concerns about the practical assessment of data information and its ability to facilitate the recreation of AI systems. He questioned how to evaluate data information without recreating the AI system.
- Practical Applications and Community Insights
- @hartmans proposed practical scenarios where data information could suffice for modifying AI models and suggested that the community’s flexibility in defining the preferred form of modification has been valuable for Debian.
- @quaid shared insights from his research on the OpenVLA project, noting its compliance with OSAID requirements. He further proposed conducting controlled experiments to verify if data information is enough to recreate models with fidelity.
- General observations
- @shujisado emphasized the need for flexible definitions in AI, drawing from open-source community experiences. Agreed on the complexity of training data issues and supported the flexible approach of OSI in defining the preferred form of modification.
- @quaid suggested practical approaches for evaluating data information and its adequacy for recreating AI models and proposed further experiments and community involvement to refine the understanding and application of data information in open-source AI.
- @jberkus asked whether OSAID will apply to licenses or systems, noting that current drafts focus on systems. He questioned if a certification program for reviewing systems as open source or proprietary is the intended direction.
- @shujisado confirmed that discussions are moving towards certifying AI systems and pointed at an existing thread. He emphasized the need for evaluating individual components of AI systems and expressed concern about OSI’s capacity to establish a certification mechanism, highlighting that it would significantly expand OSI’s role.
parallel @ Savannah: GNU Parallel 20240622 ('34 counts') released
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.
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/
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.
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 Last 2 Weeks in my GSoC II
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
Talking Drupal: Talking Drupal #456 - DDEV Grows Up
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
- DDEV Project 2024 Plans
- DDEV Contributor Live Training
- Scheduling and signup
- DDEV Discord
- Nerdsniping XKCD Comic
- Level one learning xz utils
Andrew Berry - deviantintegral
HostsNic Laflin - nLighteneddevelopment.com nicxvan John Picozzi - epam.com johnpicozzi Randy Fay - rfay
MOTW CorrespondentMartin 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:
- 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
The Drop Times: Momentum for Change
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.
Real Python: Creating Great README Files for Your Python Projects
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 ProjectsTake 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 FilesBefore 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 ]
Dirk Eddelbuettel: x13binary 1.1.61 on CRAN: Maintenance
The x13binary team is thrilled to share the availability of Release 1.1.61 of the x13binary package providing the X-13ARIMA-SEATS program by the US Census Bureau which arrived on CRAN earlier today.
This release brings two updates suggested by the tireless CRAN maintainers. Kurt Hornik suggested to now also ignore stderr when calling the x13 binary via system: it appears that builds under the new-ish and clang-based flang-new now emit on stderr even if Fortran-based binaries did not before. So we adjust. And Brian Ripley pointed out that our Makefile for creating the x13 binary was not quite as is should be, which we adjusted. And I just realized I should have named this 1.1.60-2 to follow the upstream convention but didn’t. Next time.
Courtesy of my CRANberries, there is also a diffstat report for this release showing changes to the previous release.
If you like this or other open-source work I do, you can sponsor me at GitHub.
This post by Dirk Eddelbuettel originated on his Thinking inside the box blog. Please report excessive re-aggregation in third-party for-profit settings.
Consensus Enterprises: Drupal 10 on Aegir 3: A Step-by-Step Guide
Web Wash: New Navigation Sidebar (Experimental) in Drupal 10.3
Drupal 10.3 introduces a new experimental navigation module, offering a modern alternative to the traditional toolbar.
Key features of the new navigation bar:
- Located on the left side of the screen.
- Automatically expands menus on hover.
- Allows users to drill down through configuration pages.
- Replaces the top toolbar on the home page.
To try it out:
- Ensure Drupal 10.3 is installed.
- Go to “Extend” and search for “navigation”.
- Install the “Navigation” module (not “Navigation top bar”).
The new navigation bar provides a fresh, modern look for Drupal sites. However, as an experimental module, it may contain bugs or undergo changes in future updates.
Those interested in exploring this new feature can install the navigation module and experience the updated interface firsthand.
What new Drupal 10.3 feature are you looking forward to?
LN Webworks: How To Create local Task Tabs Through A Custom Module
In Drupal, local tabs are an essential feature used to organize and display multiple configuration pages in a user-friendly manner.These tabs group related pages together, providing an intuitive and seamless navigation experience.
By using local tabs, administrators and users can easily access different settings and configurations from a single interface without having to navigate through multiple pages. This functionality enhances the overall user experience, making it easier to manage and configure various aspects of a Drupal site efficiently.
To create the Drupal Local tabs we can follow these steps:
Create A Module- First Create a module For example “custom_module”
- After that define the custom_module.info.yml File in your custom module directory
Structure:
custom_module/
Custom_module.info.yml
- In this file, you can define your module name, version, and description
name: Custom Module
description: Custom Module
type: module
core_version_requirement: ^8 || ^9 || ^10
Golems GABB: Drupal 11 Modules Overview
Have you been thinking about making a serious improvement to the performance of your Drupal site? It is supposed that Drupal 11 will be released sometime this year. So, the upcoming version of Drupal promises many big moves on many grounds, including improving several core aspects of the CMS. Here's a brief overview of what’s new in Drupal 11: