Feeds

Steve Worley at DrupalSouth 2024 Steve’s second session at DrupalSouth 2024 (Day 2) was as a co-presenter with Joseph Zhao from GovCMS. They took attendees through how they test and ensure that government websites are strong, safe and easy to use. The presentation also covered practical testing methods and tools that will help government agencies deliver high-quality digital services. View the presentation description on the DrupalSouth website

Amey Mudras and Govind Kumar Malu at DrupalSouth 2024 Amey and Govind’s session at DrupalSouth 2024 focused on simplifying the complex web of structures in Drupal and explored how consolidating components into a single directory can be a game-changer for projects. Attendees left the session armed with practical insights that can be immediately applied to enhance their Drupal projects. View the presentation description on the DrupalSouth website

Recently news went around about explicit sync being merged into Wayland protocols, and in the wake of that I saw a lot of people having questions about it, and why it was such a big deal… So here’s a short-ish explanation of what it is, why it’s needed and what the benefits are over the old model.

Why is synchronization needed?

When applications “render” things, that rendering doesn’t happen immediately. Instead, they effectively record a list of commands with OpenGL or Vulkan for the GPU to execute, and that list then gets handed to the GPU to execute at its own pace.

This is needed for performance reasons: If the CPU had to wait for the GPU to execute each command one by one, both CPU and GPU would often sit around, doing nothing except waiting for the other one to finish its task. By executing commands on the GPU while the CPU does other things, like preparing new commands for the GPU, both can do a lot more work in the same time.

However, in practice, rendering commands don’t stand alone on their own. You might be running one task to render an image, and another one to process the result into something else, or to read it back to the CPU, so that it can be saved as a file on disk. If you do that without synchronization, you might be reading from the image in the middle of rendering, or even before the GPU has started to work on the buffer at all.

The “old” model: Implicit sync

Traditionally with graphics APIs like OpenGL, the necessary synchronization has been done implicitly, without the application’s involvement. This means that the kernel and/or the userspace graphics driver look at the commands the application is sending to the GPU, check which images the commands are using, which previous tasks have to be completed before it, and potentially make the application wait until the dependencies of the commands it wants to execute are resolved.

The so-called dma buffer infrastructure that the Linux graphics stack uses for exchanging images between applications - like Wayland apps and the compositor - also uses the same model. When the render commands from the compositor try to read from an app’s buffer, the kernel will delay the command’s execution until the app has completed its rendering to the buffer.

This model makes it easy for application developers to write correctly working applications, but it can also cause issues. The most relevant of them for Wayland is that the application isn’t aware of which tasks it’s synchronizing to, and it can happen that you accidentally and unknowingly synchronize to GPU commands that don’t have any relevance to your task.

This has been a problem that Wayland compositors have been affected by for a long time: When presenting application images to the screen, compositors picked the latest image that the application has provided, which could still have GPU tasks running on it, instead of an earlier image that’s actually ready for presentation. This meant that sometimes presentation was delayed by the kernel, and you’d see a frame be dropped entirely, instead of just a slightly older image. This issue has been solved for most compositors in the last two years using what’s effectively explicit sync through a backdoor; I won’t explain the details of that here, but you can read Michel Dänzer’s blog post about it instead.

The “new” model: Explicit sync

The name already suggests exactly what it does: Instead of the driver or the kernel doing potentially unexpected things in the background, the application explicitly tells the relevant components (driver / kernel / compositor / other apps) when rendering is complete and what tasks to synchronize to in the first place, using various synchronization primitives.

On the application side, explicit sync is used in Vulkan, and the Wayland protocol specifically is used internally by OpenGL and Vulkan drivers to synchronize with the Wayland compositor.

This explicit way of synchronizing GPU commands doesn’t just help avoid accidental synchronizations, it also helps improve performance by reducing the work drivers have to do. Instead of having to figure out the dependencies of tasks from a relatively opaque list of commands, apps just tell them directly.

An important thing to mention here is that we already had a protocol for explicit sync, zwp_linux_explicit_synchronization_unstable_v1, but it shared a limitation with implicit sync: In order to get a synchronization primitive, it still required the GPU commands to be first submitted to the kernel. The new protocol in contrast allows to create and share synchronization primitives without submitting work to the GPU first, which - at least in theory - will allow applications to squeeze a little bit more performance out of your hardware in the future.

Do keep in mind though that these performance improvements are minor. While there may be some special cases where implicit sync between app and compositor was the bottleneck before, you’re unlikely to notice the individual difference between implicit and explicit sync at all.

Why the big fuzz then?

If we already have “explicit sync through a backdoor”, and explicit sync doesn’t bring major performance improvements for everyone, why is it such big news then?

The answer is simple: The proprietary NVidia driver doesn’t support implicit sync at all, and neither commonly used compositors nor the NVidia driver support the first explicit sync protocol, which means on Wayland you get significant flickering and frame pacing issues. The driver also ships with some workarounds, but they don’t exactly fix the problem either:

• it delays Wayland commits until rendering is completed, but it goes against how graphics APIs work on Wayland and can cause serious issues, even crash apps in extreme cases
• it delays X11 presentation until rendering is completed, but as Xwayland copies window contents sometimes, that still often causes glitches if Xwayland is also using the NVidia GPU for those copies

There’s been a lot of discussions around the internet between people experiencing the issues constantly, and others not seeing any, and now you should know why it doesn’t seem to affect everyone: It’s not a deterministic “this doesn’t work” problem but a lack of synchronization, which means that a lot of factors - like the apps you use, the CPU and GPU you have, the driver version, the kernel, compositor and so on - decide whether or not you actually see the issue.

With the explicit sync protocol being implemented in compositors and very soon in Xwayland and the proprietary NVidia driver, all those problems will finally be a thing of the past, and the biggest remaining blocker for NVidia users to switch to Wayland will be gone.

The diffoscope maintainers are pleased to announce the release of diffoscope version 263. This version includes the following changes:

[ Chris Lamb ] * Add support for the zipdetails(1) tool included in the Perl distribution. Thanks to Larry Doolittle et al. for the pointer to this tool. * Don't use parenthesis within test "skipping…" messages; PyTest adds its own parenthesis, so we were ending up with double nested parens. * Fix the .epub tests after supporting zipdetails(1). * Update copyright years and debian/tests/control. [ FC (Fay) Stegerman ] * Fix MozillaZipContainer's monkeypatch after Python's zipfile module changed to detect potentially insecure overlapping entries within .zip files. (Closes: reproducible-builds/diffoscope#362)

You find out more by visiting the project homepage.

You’ve probably heard of the recent backdoor in xz. There have been a lot of takes on this, most of them boiling down to some version of:

The problem here is with Open Source Software.

I want to say not only is that view so myopic that it pushes towards the incorrect, but also it blinds us to more serious problems.

Now, I don’t pretend that there are no problems in the FLOSS community. There have been various pieces written about what this issue says about the FLOSS community (usually without actionable solutions). I’m not here to say those pieces are wrong. Just that there’s a bigger picture.

So with this xz issue, it may well be a state actor (aka “spy”) that added this malicious code to xz. We also know that proprietary software and systems can be vulnerable. For instance, a Twitter whistleblower revealed that Twitter employed Indian and Chinese spies, some knowingly. A recent report pointed to security lapses at Microsoft, including “preventable” lapses in security. According to the Wikipedia article on the SolarWinds attack was facilitated by various carelessness; including passwords being posted to Github and weak default passwords. They directly distributed malware-infested updates, encouraged customers to disable anti-malware tools when installing SolarWinds products, and so forth.

It would be naive indeed to assume that there aren’t black hat actors among the legions of programmers employed by companies that outsource work to low-cost countries — some of which have challenges with bribery.

So, given all this, we can’t really say the problem is Open Source. Maybe it’s more broad:

The problem here is with software.

Maybe that inches us closer, but is it really accurate? We have all heard of Boeing’s recent issues, which seem to have some element of root causes in corporate carelessness, cost-cutting, and outsourcing. That sounds rather similar to the SolarWinds issue, doesn’t it?

Well then, the problem is capitalism.

Maybe it has a role to play, but isn’t it a little too easy to just say “capitalism” and throw up our hands helplessly, just as some do with FLOSS as at the start of this article? After all, capitalism also brought us plenty of products of very high quality over the years. When we can point to successful, non-careless products — and I own some of them (for instance, my Framework laptop). We clearly haven’t reached the root cause yet.

And besides, what would you replace it with? All the major alternatives that have been tried have even stronger downsides. Maybe you replace it with “better regulated capitalism”, but that’s still capitalism.

Then the problem must be with consumers.

As this argument would go, it’s consumers’ buying patterns that drive problems. Buyers — individual and corporate — seek flashy features and low cost, prizing those over quality and security.

No doubt this is true in a lot of cases. Maybe greed or status-conscious societies foster it: Temu promises people to “shop like a billionaire”, and unloads on them cheap junk, which “all but guarantees that shipments from Temu containing products made with forced labor are entering the United States on a regular basis“.

But consumers are also people, and some fraction of them are quite capable of writing fantastic software, and in fact, do so.

So what we need is some way to seize control. Some way to do what is right, despite the pressures of consumers or corporations.

Ah yes, dear reader, you have been slogging through all these paragraphs and now realize I have been leading you to this:

Then the solution is Open Source.

Indeed. Faults and all, FLOSS is the most successful movement I know where people are bringing us back to the commons: working and volunteering for the common good, unleashing a thousand creative variants on a theme, iterating in every direction imaginable. We have FLOSS being vital parts of everything from $30 Raspberry Pis to space missions. It is brining education and communication to impoverished parts of the world. It lets everyone write and release software. And, unlike the SolarWinds and Twitter issues, it exposes both clever solutions and security flaws to the world.

If an authentication process in Windows got slower, we would all shrug and mutter “Microsoft” under our breath. Because, really, what else can we do? We have no agency with Windows.

If an authentication process in Linux gets slower, anybody that’s interested — anybody at all — can dive in and ask “why” and trace it down to root causes.

Some look at this and say “FLOSS is responsible for this mess.” I look at it and say, “this would be so much worse if it wasn’t FLOSS” — and experience backs me up on this.

FLOSS doesn’t prevent security issues itself.

What it does do is give capabilities to us all. The ability to investigate. Ability to fix. Yes, even the ability to break — and its cousin, the power to learn.

And, most rewarding, the ability to contribute.

We’re excited to announce the April 2024 release of the Python and Jupyter extensions for Visual Studio Code!

This release includes the following announcements:

• Improved debug config flow for Flask and Django
• Module and import analysis on Jupyter’s Run Dependent Cells with Pylance
• Hatch environment discovery
• Automatic environment selection for pipenv, pyenv, and Poetry projects
• Report Issue command improvements

If you’re interested, you can check the full list of improvements in our changelogs for the Python, Jupyter and Pylance extensions.

Improved debug config flow for Flask and Django

Creating launch configurations for Flask and Django apps just got easier! Improvements have been made to detect possible startup files in your workspace when creating a launch.json for your web app. For Django, the Python Debugger extension looks for manage.py or app.py files in the root or a subdirectory one level lower in your workspace. For Flask, the extension looks for wsgi.py, app.py, or init.py files that contain the declaration of a Flask application (for example, app = Flask()). If none of those files are not found in the project, the dropdown shows a Default option for the corresponding project type, even though that file may not be present.

In the case your file was not detected, you can enter the file path directly or browse other files in your directory.

Module and import analysis on Jupyter’s Run Dependent Cells with Pylance

Dependency analysis for Jupyter cells has improved with the latest Pylance pre-release. With these changes, Pylance aids Jupyter in understanding module imports, which is especially useful when you have a cell that imports a module that was defined in a previous cell.

To enable this feature, install the latest Pylance pre-release in VS Code Insiders, and enable the jupyter.executionAnalysis.enabled and notebook.consolidatedRunButton settings.

Hatch environment discovery

Hatch environments are now discovered and activated, by default, similar to other common environments, such as Venv, Conda, and Poetry. Furthermore, in the case of Hatch where an explicit environment identifier is not registered, the extension is able to determine the environment type (Hatch) from the environment locator.

Automatic environment selection for pipenv, pyenv, and Poetry projects

If your workspace contains a pipenv, pyenv, or Poetry environment, the corresponding environment is now automatically selected for your workspace. Previously, the extension correctly discovered these environments, but selected the default global interpreter, requiring you to manually select the appropriate environment for your workspace. Now, the Python extension infers the default environment based on its presence and any corresponding configuration files. For example, in the case of pyenv, the extension looks at the .python-version file to automatically select the appropriate interpreter for the workspace.

Report Issue command improvements

The Python and Python Debugger extensions have adopted changes making it easier for you to report issues to our repos! Filing an issue with the Report Issue command (workbench.action.openIssueReporter) does most of the heavy lifting, prompting you for additional info so our team can efficiently triage the problem you are encountering.

To file an issue using the Report Issue command for @vscode-python or @vscode-python-debugger, choose Python or Python Debugger respectively from the extension dropdown.

Other Changes and Enhancements

We have also added small enhancements and fixed issues requested by users that should improve your experience working with Python and Jupyter Notebooks in Visual Studio Code. Some notable changes include:

• Better error messages when “Move to file” refactoring fails in @pylance-release#4345
• REPL Smart Send (python.REPL.enableREPLSmartSend) is now enabled by default

We would also like to extend special thanks to this month’s contributors:

• @bn-d Update minimum VS Code version in @vscode-black-formatter#445
• @flying-sheep Add support for Hatch environments in @vscode-python#22779

Call for Community Feedback

As we are planning and prioritizing future work, we value your feedback! Below are a few issues we would love feedback on:

• Design proposal for test coverage in (@vscode-python#22827)

Try out these new improvements by downloading the Python extension and the Jupyter extension from the Marketplace, or install them directly from the extensions view in Visual Studio Code (Ctrl + Shift + X or ⌘ + ⇧ + X). You can learn more about Python support in Visual Studio Code in the documentation. If you run into any problems or have suggestions, please file an issue on the Python VS Code GitHub page.

The post Python in Visual Studio Code – April 2024 Release appeared first on Python.

DrupalCamp New Jersey unites hundreds of attendees with varying professional backgrounds to share their knowledge, ideas, and passion for the Drupal project. My first DrupalCamp NJ was in 2023 and it was also my first experience of presenting at a conference! It was a nerve-wracking but fun experience—and since then I’ve delivered 9 conference presentations across Canada, the U.S., and France on topics like accessibility, caching, migrations, and discovery.

Fast forward to March 2024: I returned to DrupalCamp NJ to present another session and deliver training.  Eight of our team members piled into a minivan to make the 700 km road trip from Montreal to New Jersey. The event was held in Princeton University’s Robertson Hall—a stunning piece of architecture set in a beautiful plaza. We joined more than 150 participants for the three-day event, which featured 23 incredible talks and three days of training.

Read on for our highlights! Plus, learn what to expect from your first DrupalCamp.

 

Princeton University hosted DrupalCamp New Jersey, so we got to revisit our client’s stunning campus.
What We Presented

What Non-Developers Should Know About Content Migration

I co-presented this session with my colleague Marien Regnault, Drupal Developer. We shared insights that our team has gained from dozens of complex migrations over the years, including Drupal 7 to Drupal 10 migrations. We helped a non-technical audience understand the process at a high level with a focus on planning, preparation, dealing with common challenges, and collaborating with developers. 

Watch the talk. 

 

Harmonizing Creativity and Code: Collaboration in Design Systems

This session was delivered by my colleagues Bryenne Kay, UX/UI Designer and Robert Ngo, Solutions Architect. It looked at building and maintaining a design system from both a developer’s and designer’s perspective. Bryenne and Robert dived into creating libraries of reusable Single Directory Components (SDCs), streamlining workflows, and improving collaboration between teams. 

Watch the talk. 

 

Bryenne at her first ever DrupalCamp, waiting with Robert to begin their presentation on design systems. 

 

Use Drupal as No-Code Content Platform for Your Next(.js) Decoupled Project

Our Director of Technology, Simon Morvan, talked about the core principles of a decoupled Drupal architecture and why it improves performance, user experience, SEO, and security. He demonstrated that this approach doesn’t require back-end development, making Drupal a low-cost alternative to other no-code options like commercial cloud SaaS solutions. Simon used our collaboration with Planned Parenting Direct (PPD) as an example. Interestingly, the co-founder of Pantheon—which hosts the PPD website—was in the audience! This led to some interesting additional questions and answers at the end of the session. 

 

Revamp or Redesign: Navigating the Crossroads of Website Evolution

Evolving Web has a long-standing relationship with Princeton University, so I was delighted to co-present this session with the institution’s Assistant Director of Web & Digital Initiatives, John Cloys, along with Alex Dergachev, Co-Founder and Technical Lead at Evolving Web. We explored the ever-changing nature of the digital landscape, and addressed the challenge of deciding when to update your website, how, and how much.

Watch the talk. 

 

Drupal Site Building & Tools for Digital Asset Management

It was so much fun to deliver this training session with my colleague Marien and Acquia’s Senior Solutions Architect, Martin Anderson-Clutz. It was my first time providing training in-person since I started at Evolving Web, and I really enjoyed the advantages of being physically present; I was able to see people’s reactions and give more personal support than is possible over Zoom. The course gave participants a run-through of the Drupal site building process—including creating an information architecture in Drupal, and leveraging media management and Acquia DAM on top of Drupal. 
 

“This was my first DrupalCamp. It made me realize that the Drupal community isn’t just a source of modules I can use—it’s a community of people with common goals who collaborate with and support one another.”

– Marien Regnault, Drupal Developer, Evolving Web

What We Attended

Intermediate Drupal Front End Development 

Led by Ashraf Abed at DebugAcademy.com, this course shed light on some of the most powerful aspects of Drupal's front-end system, including render arrays, caching, and twig. It was fascinating to discover how powerful render arrays are for piling on properties all the way down the stack. We heard about useful tools like Twig Xdebug, which allows you to use Xdebug breakpoints with Twig templates. And we learned some best practices for security, such as only translating hardcoded strings to avoid exploits from user-generated content. 

Watch the talk. 

 

Navigating The Migration Landscape: Lessons Learned From Princeton University’s Migration of Over 1000 Drupal Websites To A Single Platform 

Led by Mandee Englert and Jill Moraca, this talk provided an impressive example of a highly complex migration and the planning, organization, and post-migration processes that made it a success. We left with plenty of useful ideas to implement and recommend to clients. 
 

Between sessions, our team enjoyed wandering around Princeton University’s beautiful campus in the sunny weather. 

 

Drupal be DAMed

Ray Saltini and David Hernandez explored key reasons and considerations for adopting a Digital Asset Management (DAM) solution. We really enjoyed their practical insights into preparing, optimizing, and scaling a DAM solution, as well as an exploration of alternatives. Overall, a DAM good session. 

Watch the talk. 

 

Protecting your site with Automatic Updates

We were excited to hear updates from Acquia’s Ted Bowman on his almost-complete work to bring automatic code updates to Drupal deployment. Ted  gave a refresher on the Automatic Updates module, including how to determine if your hosting is compatible and ensure your site is configured to run it securely. 

Watch the talk. 

 

See what you missed at DrupalCamp Florida 2024, too!

 

“It was my 9th visit to Drupalcamp NJ so one of the best parts is seeing old clients, collaborators, and dozens of other amazing Drupal community members who have become friends.”

– Alex Dergachev, Co-Founder & Technical Lead, Evolving Web 

What to Expect From Your First DrupalCamp

DrupalCamps are regional, community-driven events that foster innovation, collaboration, and skill enhancement within the Drupal ecosystem. Each has its own style and flow, but they all have consistent themes at their core:

1. Knowledge sharing. DrupalCamps are a great place to swap ideas, gain skills, and learn best practices. Sessions, workshops, and trainings provide more structured learning, but there’s also a treasure of wisdom to be found simply by chatting to fellow participants at lunch. Success stories and case studies also serve as valuable inspiration for future projects. 
2. Community building. DrupalCamps encourage professionals to connect, collaborate, and develop valuable relationships. The organizers emphasize inclusivity, welcoming the participation of diverse groups and finding ways to lower barriers and increase accessibility. 
3. Volunteerism. DrupalCamps are organized and run by volunteers, making them a sustainable model and a true reflection of the Drupal community’s interests and values. Volunteering opportunities are also a great opportunity to gain exposure and experience through speaking, training, or organizing. 
4. Collaboration. DrupalCamps often feature hackathons, collaborative workshops, and contributions days focused on improving open source projects such as Drupal core, modules, and themes. These activities foster team-work beyond the event, too. More than one Drupal initiative has started out as a conversation at a DrupalCamp or DrupalCon. 
5. Innovation. Participants are encouraged to collaboratively solve real-world problems, and informed about new technologies, trends, and challenges. It’s a chance to not only get ahead of the curve but also to help shape open source innovation. 
6. Feedback. DrupalCamps serve as platforms for gathering UX feedback on community-driven initiatives that support Drupal’s growth. As a Drupal user, this is an opportunity to ensure your needs and priorities are considered. 
7. Professional development. DrupalCamps are a friendly space where you can connect with potential employers, find mentorship, and gain insights from peers and experts. There are sessions where you can develop your technical, strategic, creative, and leadership skills. Also, volunteering to lead a session or workshop can help you gain industry exposure and carve out a niche. 

Interested in attending? Visit drupal.org to find a DrupalCamp near you. 

If you’re looking for an event that covers a wider variety of  topics, with fewer simultaneous talks, check out EvolveDrupal! This unique summit fosters open source innovation and digital transformation with sessions on technology, UX design, digital strategy, content, marketing, higher education, and much more. The next EvolveDrupal summit is taking place in Atlanta on April 12. We hope to see you there!

+ more awesome articles by Evolving Web

Dive into the final chapter of The DropTimes' "Women in Drupal" series, a captivating campaign launched to celebrate International Women's Day 2024. This concluding segment brings together the voices and visions of women who have shaped the Drupal community, driving forward the message of inclusion and diversity. Featured individuals like Kat Shaw, Nneka Hector, Nikita Aswani, Nina Ogor, Masami Suzuki, Tearyne D. A., Anushri Kumari, Shefali Shetty, Aastha Shrivastava, and Libbna Mathew share their experiences, challenges, and hopes for a more inclusive future.

From advocating for web accessibility to fostering diversity in tech leadership, their stories reflect a collective aspiration for change and renewal within the Drupal ecosystem and beyond. Join us in this inspiring journey as we explore the powerful narratives of these remarkable women, each contributing to the vibrant tapestry of Drupal. It's a call to inspire inclusion, celebrate achievements, and embrace the diverse voices that propel the community forward. Don't miss this insightful finale of "Women in Drupal" – let's inspire inclusion together!

Across its 50-year history, the Sydney Opera House has welcomed musicians, dancers, actors, playwrights, filmmakers, contemporary artists, and thinkers who have both challenged and defined the cultural scene. As a result, the Sydney Opera House draws millions of visitors from around the world each year.

Not only is the Sydney Opera House of incredible cultural importance, it's also an architectural masterpiece. Its unique design makes it one of the most iconic buildings in the world, and has earned it a place as a UNESCO World Heritage Site.

Last year, the Sydney Opera House chose to migrate its website to Drupal. Today, it is running Drupal 10. The decision by such a prestigious institution to relaunch their website on Drupal highlights Drupal's flexibility, security, and ability to manage complex websites.

A couple of weeks ago, during my visit to Australia, I met with the Drupal team at the Sydney Opera House. I was particularly impressed by the team's dedication to using Open Source to expand cultural access and their enthusiasm for collaborating with other arts and cultural organizations. Their focus on innovation, inclusivity, and collaboration perfectly aligns with the core values of Open Source and the Open Web. Drupal is such a great solution for them!

New “netplan status –diff” subcommand, finding differences between configuration and system state

As the maintainer and lead developer for Netplan, I’m proud to announce the general availability of Netplan v1.0 after more than 7 years of development efforts. Over the years, we’ve so far had about 80 individual contributors from around the globe. This includes many contributions from our Netplan core-team at Canonical, but also from other big corporations such as Microsoft or Deutsche Telekom. Those contributions, along with the many we receive from our community of individual contributors, solidify Netplan as a healthy and trusted open source project. In an effort to make Netplan even more dependable, we started shipping upstream patch releases, such as 0.106.1 and 0.107.1, which make it easier to integrate fixes into our users’ custom workflows.

With the release of version 1.0 we primarily focused on stability. However, being a major version upgrade, it allowed us to drop some long-standing legacy code from the libnetplan1 library. Removing this technical debt increases the maintainability of Netplan’s codebase going forward. The upcoming Ubuntu 24.04 LTS and Debian 13 releases will ship Netplan v1.0 to millions of users worldwide.

Highlights of version 1.0

In addition to stability and maintainability improvements, it’s worth looking at some of the new features that were included in the latest release:

• Simultaneous WPA2 & WPA3 support.
• Introduction of a stable libnetplan1 API.
• Mellanox VF-LAG support for high performance SR-IOV networking.
• New hairpin and port-mac-learning settings, useful for VXLAN tunnels with FRRouting.
• New netplan status –diff subcommand, finding differences between configuration and system state.

Besides those highlights of the v1.0 release, I’d also like to shed some light on new functionality that was integrated within the past two years for those upgrading from the previous Ubuntu 22.04 LTS which used Netplan v0.104:

• We added support for the management of new network interface types, such as veth, dummy, VXLAN, VRF or InfiniBand (IPoIB). 
• Wireless functionality was improved by integrating Netplan with NetworkManager on desktop systems, adding support for WPA3 and adding the notion of a regulatory-domain, to choose proper frequencies for specific regions. 
• To improve maintainability, we moved to Meson as Netplan’s buildsystem, added upstream CI coverage for multiple Linux distributions and integrations (such as Debian testing, NetworkManager, snapd or cloud-init), checks for ABI compatibility, and automatic memory leak detection. 
• We increased consistency between the supported backend renderers (systemd-networkd and NetworkManager), by matching physical network interfaces on permanent MAC address, when the match.macaddress setting is being used, and added new hardware offloading functionality for high performance networking, such as Single-Root IO Virtualisation virtual function link-aggregation (SR-IOV VF-LAG).

The much improved Netplan documentation, that is now hosted on “Read the Docs”, and new command line subcommands, such as netplan status, make Netplan a well vested tool for declarative network management and troubleshooting.

Integrations

Those changes pave the way to integrate Netplan in 3rd party projects, such as system installers or cloud deployment methods. By shipping the new python3-netplan Python bindings to libnetplan, it is now easier than ever to access Netplan functionality and network validation from other projects. We are proud that the Debian Cloud Team chose Netplan to be the default network management tool in their official cloud-images for Debian Bookworm and beyond. Ubuntu’s NetworkManager package now uses Netplan as it’s default backend on Ubuntu 23.10 Desktop systems and beyond. Further integrations happened with cloud-init and the Calamares installer.

Please check out the Netplan version 1.0 release on GitHub! If you want to learn more, follow our activities on Netplan.io, GitHub, Launchpad, IRC or our Netplan Developer Diaries blog on discourse.

I was invited to join Mozilla and the Columbia Institute of Global Politics in an effort that explores what “open” should mean in the AI era. A cohort of 40 leading scholars and practitioners from Open Source AI startups and companies, non-profit AI labs, and civil society organizations came together on February 29 at the Columbia Convening to collaborate on ways to strengthen and leverage openness for the good of all. We believe openness can and must play a key role in the future of AI. The Columbia Convening took an important step toward developing a framework for openness in AI with the hope that open approaches can have a significant impact on AI, just as Open Source software did in the early days of the internet and World Wide Web. 

This effort is aligned and contributes valuable knowledge to the ongoing process to find the Open Source AI Definition. 

As a result of this first meeting of Columbia Convening, two readouts have been published; a technical memorandum for technical leaders and practitioners who are shaping the future of AI, and a policy memorandum for policymakers with a focus on openness in AI.

Technical readout

The Columbia Convening on Openness and AI Technical Readout was edited by Nik Marda with review contributions from myself, Deval Pandya, Irene Solaiman, and Victor Storchan.

The technical readout highlighted the challenges of understanding openness in AI. Approaches to openness are falling under three categories: gradient/spectrum, criteria scoring, and binary. The OSI is championing a binary approach to openness, where AI systems are either “open” or “closed” based on whether they meet a certain set of criteria.

The technical readout also provided a diagram that shows how the AI stack may be described by the different dimensions (AI artifacts, documentation, and distribution) of its various components and subcomponents.

Policy readout

The Columbia Convening on Openness and AI Policy Readout was edited by Udbhav Tiwari with review contributions from Kevin Klyman, Madhulika Srikumar, and myself.

The policy readout highlighted the benefits of openness, including:

• Enhancing reproducible research and promoting innovation
• Creating an open ecosystem of developers and makers
• Promoting inclusion through open development culture and models
• Facilitating accountability and supporting bias research
• Fostering security through widespread scrutiny
• Reducing costs and avoiding vendor lock-In
• Equipping supervisory authorities with necessary tools
• Making training and inference more resource-efficient, reducing environmental harm
• Ensuring competition and dynamism
• Providing recourse in decision-making

The policy readout also showcased a table with the potential benefits and drawbacks of each component of the AI stack, including the code, datasets, model weights, documentation, distribution, and guardrails.

Finally, the policy readout provided some policy recommendations:

• Include standardized definitions of openness as part of AI standards
• Promote agency, transparency and accountability
• Facilitate innovation and mitigate monopolistic practices
• Expand access to computational resources
• Mandate risk assessment and management for certain AI applications
• Hold independent audits and red teaming
• Update privacy legislation to specifically address AI challenges
• Updated legal framework to distinguish the responsibilities of different actors
• Nurture AI research and development grounded in openness
• Invest in education and specialized training programs
• Adapt IP laws to support open licensing models
• Engage the general public and stakeholders

You can follow along with the work of Columbia Convening at mozilla.org/research/cc and the work from the Open Source Initiative on the definition of Open Source AI at opensource.org/deepdive.

Steve Worley at DrupalSouth 2024 — Day 1 Steve’s session on Day 1 at DrupalSouth 2024 looked at the benefits of a static Drupal website and different static options, including QuantCDN . From security and performance to scalability and greenness, the session explored the many big wins of static Drupal. View the presentation description on the DrupalSouth website

PyCharm 2024.1 is out with many key updates, including full line code completion for frontend frameworks, documentation preview for Hugging Face models and datasets, and multiple improvements to the user experience – just to name a few! You can download the latest version from our download page, or even easier, update your current version through […]

Developing embedded software is notoriously difficult – how can we simplify the process? Fortunately, there are lots of techniques you can use daily to help streamline your development.

Embracing Automation

The specialized nature of embedded systems extends the ramp-up time for developers and necessitates a higher level of expertise. Automating hardware-specific tasks, such as deploying applications to boards, initializing debuggers, and resetting systems, can significantly reduce the time penalties that embedded developers face. Using automation to streamline setup for new engineers, everyday development routines, and testing workflows not only speeds up development but also ensures consistency.

Prototyping is Vital

Prototyping is an indispensable part of embedded software development. Given the high cost and complexity associated with changes to software and hardware later in a project, early detection of potential issues is invaluable. Embedded prototypes need not be elaborate; rather, they should precisely address specific aspects such as hardware selection, software performance, integration strategies, and user interface design.

Prototyping serves multiple purposes, from assessing hardware performance metrics to conducting preliminary user-interface tests. Importantly, prototypes can also help pre-empt critical issues, form the basis of future test scaffolding, avoid the need to discard early code iterations, and even lay the groundwork for initial development.

Integrate Early and Often

Integration represents a critical phase in development, one that brings together disparate pieces of the software puzzle. This includes various internal components developed by separate teams — like the middleware stack, user interface, and backend services — as well as third-party software. While the temptation might be to delay this challenging step, early and regular integration is the wiser approach. This proactive strategy facilitates the early identification and resolution of issues that are not evident in unit testing, helping to avoid last-minute crises.

Optimize, but Carefully

The famous caution against premature optimization, coined by Donald Knuth in the 1960s, remains relevant today, especially where the interplay between hardware and software leads to complex performance issues in embedded systems. The key is not to avoid optimization but rather approach it with a thorough understanding of your application’s specific performance bottlenecks. Optimizing is both a time-consuming activity and a source of potential bugs, so optimize only when you need to and when you can show it can have a substantial impact. Use tools like perf, hotspot, and various other memory profilers to accurately diagnose performance problems. Once you have a clear understanding of the issues at hand, you can formulate an effective optimization strategy and establish benchmarks to maintain performance standards.

Byte-Wise, Megabyte-Foolish: A Cautionary Tale

It’s important not to lose sight of the forest for the trees. We learned this firsthand when helping a client who optimized their application’s search functionality to an impressive degree, only to overlook a major memory drain caused by an inefficient background image file format. This oversight led to unnecessary memory consumption that eclipsed the benefits gained by optimizing their search feature’s memory use – a reminder to consider the broader implications before optimizing.

Best Practices

For those looking to delve deeper into the intricacies of embedded system design, our guides, Designing Your First Embedded Linux Device and Best Practices: Embedded Development provide insights and a wealth of detailed best practices to ensure your project begins and stays on a solid foundation.

If you want to learn more about embedded Linux, come talk to us at Embedded World 2024 (9th-11th April) in Nürnberg: KDAB at EW24.

About KDAB

If you like this article and want to read similar material, consider subscribing via our RSS feed.

Subscribe to KDAB TV for similar informative short video content.

KDAB provides market leading software consulting and development services and training in Qt, C++ and 3D/OpenGL. Contact us.

The post Streamlining Strategies for Embedded Software Development appeared first on KDAB.

Interested in data science but you're not quite working in it yet? In software, getting that very first job can truly be the hardest one to land. On this episode, we have Avery Smith from Data Career Jumpstart here to share his advice for getting your first data job.<br/> <br/> <strong>Episode sponsors</strong><br/> <br/> <a href='https://talkpython.fm/sentry'>Sentry Error Monitoring, Code TALKPYTHON</a><br> <a href='https://talkpython.fm/posit'>Posit</a><br> <a href='https://talkpython.fm/training'>Talk Python Courses</a><br/> <br/> <strong>Links from the show</strong><br/> <br/> <div><b>Avery Smith</b>: <a href="https://www.linkedin.com/in/averyjsmith/" target="_blank" rel="noopener">www.linkedin.com</a><br/> <b>Data Career Jumpstart</b>: <a href="https://www.datacareerjumpstart.com/" target="_blank" rel="noopener">www.datacareerjumpstart.com</a><br/> <b>Data Nerd Site</b>: <a href="https://datanerd.tech" target="_blank" rel="noopener">datanerd.tech</a><br/> <b>Write C# LINQ queries to query data</b>: <a href="https://learn.microsoft.com/en-us/dotnet/csharp/linq/get-started/write-linq-queries" target="_blank" rel="noopener">learn.microsoft.com</a><br/> <b>A faster way to build and share data apps</b>: <a href="https://streamlit.io" target="_blank" rel="noopener">streamlit.io</a><br/> <b>Plotly Dash</b>: <a href="https://dash.plotly.com" target="_blank" rel="noopener">dash.plotly.com</a><br/> <br/> <b>Michael's Keynote: State of Python in 2024</b>: <a href="https://www.youtube.com/watch?v=coz1CGRxjQ0" target="_blank" rel="noopener">youtube.com</a><br/> <b>Watch this episode on YouTube</b>: <a href="https://www.youtube.com/watch?v=0G89ZY5IWUM" target="_blank" rel="noopener">youtube.com</a><br/> <b>Episode transcripts</b>: <a href="https://talkpython.fm/episodes/transcript/455/land-your-first-data-job" target="_blank" rel="noopener">talkpython.fm</a><br/> <br/> <b>--- Stay in touch with us ---</b><br/> <b>Subscribe to us on YouTube</b>: <a href="https://talkpython.fm/youtube" target="_blank" rel="noopener">youtube.com</a><br/> <b>Follow Talk Python on Mastodon</b>: <a href="https://fosstodon.org/web/@talkpython" target="_blank" rel="noopener"><i class="fa-brands fa-mastodon"></i>talkpython</a><br/> <b>Follow Michael on Mastodon</b>: <a href="https://fosstodon.org/web/@mkennedy" target="_blank" rel="noopener"><i class="fa-brands fa-mastodon"></i>mkennedy</a><br/></div>

If you have used a moderately complex application there are chances that you have interacted with what is called a “modal” dialog. A modal dialog is a dialog that requires you to close/address it before you can continue interacting with the main application window. This can be implemented by the application in a straightforward manner but compositor didn’t know if a dialog was modal or not.

That is until now the new xdg-dialog-v1 protocol allows applications to mark their dialogs as modal or not modal. This allows the compositor to adapt its behavior according to this hint. For example when trying to activate the main window it can activate the modal dialog instead. It also enables KWin to use the darkening effect on the parent window on Wayland.

I implemented support for the protocol into KWin and Qt which will be part of the Plasma 6.1 and Qt 6.8 releases respectively. The protocol was created from functionality in GTK and Mutter by Carlos Garnacho and I am happy seeing the overall Wayland eco-system now being able to benefit from it.

From the Women in Drupal Awards to news of exciting developments in Drupal and inspiring keynotes, there was much to take away from DrupalCon Lille

Learn why attendees at DrupalCon Lille were abuzz over the intersection of artificial intelligence and open source platform Drupal

Several conference events underscore the values of accessibility and inclusion for the Drupal community

Discover what Dries Buytaert, creator of Drupal and cofounder of Acquia, had to say in his much anticipated Driesnote at DrupalCon Lille