Over the past few years, virtual events have thrived. In-person events are back now, but it's important to keep in mind that virtual events didn't just come out of nowhere. Many of us were actually doing a lot of different online events even before they became popular. Many communities held hackathons, bug and issue triaging, webinars, and so on, as virtual events. They brought community members together for collaboration and education. Virtual events have improved since then, largely out of necessity, and I think we've all learned a lot. In this article, I consider how virtual and physical events can co-exist to render an improved event experience for everyone.

Costs and crowds

I don't think anyone wants to go back to the days when all events were happening on screens. But virtual events do have important advantages compared to in-person events. To begin with, it is relatively easy to start a virtual event as you often don't need much beyond meeting and streaming platforms. It can be as basic as live streaming from a video chat platform. This is especially useful for small communities that don't have a large events budget. In fact, a virtual event platform provides an opportunity to build an audience before you start making significant investments in in-person events.

The lower cost and logistical hurdles of virtual meetings don't just apply to the event organizer. It matters to attendees and community members too. A typical meetup is likely to last for 60 to 90 minutes. Is everyone always happy to commute 30 minutes each way to get to the meeting venue? A meetup in a virtual format can lower the participation barrier for attendees. I think this is one of the reasons that many meetups are continuing in virtual formats today.

The cost of doing virtual events is much lower, so there's low-risk of experimenting with different content, format, target audiences, and so on. Even if a new event isn't a huge success, you won't have to invest a large budget on the venue, equipment, people, travel, and so on. And you're able to get some valuable learning from the event no matter what.

Practical events

In addition, there are some activities that are just well-suited for virtual events. Things like documentation and bug triaging are crucial in open source communities. Despite this most people see them more like chores that they'd rather avoid. Why not have a short one to two day window where community members come together online so they can work on these chores together while supporting each other?

Hybrid events

Many events are going hybrid now, with both in-person and virtual components. By hybrid, I don't mean just broadcasting in-person sessions from conference facilities. Many have separate tracks for in-person and virtual participants. FOSDEM 2023 is a great example of a hybrid event, with separate online rooms.

Some utilize virtual tracks for "Day 0" events (orientation, project team meetings, meetups, and so on). This way, people who aren't able to travel to the in-person conference can still participate in the earliest events. By having a separate virtual track, you can potentially reduce the total length of the in-person conference. This means people don't have to be away from home as long as a 100% in-person event.

The dos and don'ts

Here are some tips based on my experience of attending and organizing virtual events.

• DON'T have the same structure as in-person events. When you have an event online, you wouldn't want to ask the audience to sit through a full day of presentations. It's difficult for most people to stare at their screens for a long period of time. If you have more than four hours of content, consider spreading the event over a few days so that attendees only need to sit through a maximum of a couple of hours of presentations each day. You also don't always need to add breaks between sessions in virtual events because people aren't moving to different rooms. As a matter of fact, by hot switching to the next session, you're less likely to lose attendees between presentations.

• DON'T put a wall around the content after the event. I recently registered and attended an event and was told that slides and recordings would be available a few weeks after the event. When I returned to the event page a few weeks later, it asked me to register with my email address to get access to the content! I understand people's desire to collect leads. But if people had to register for the event already, or the event was live-streamed, it's not appropriate to ask them to share their contact information. Instead, make the content accessible to anyone.

• DON'T force synchronous participation from attendees. One of the key benefits of virtual events is that it's easier for everyone to attend or participate. If a person cannot watch a presentation live, provide ways for them to interact with presenters and other attendees asynchronously.

• DO make content available prior to events. Online events make it easier for community members to participate asynchronously. Things like publishing slides or Q&A pages ahead of time allow attendees to review content and post questions that presenters can address during and after the session. Also, if you're doing a hands-on workshop, publishing a prep guide before the event allows attendees to set up their environment so that it's easier to follow along during the presentation and play around in their sandbox.

• DO have presenters available for asynchronous Q&A sessions. Some of the virtual events I enjoyed had dedicated Q&A channels (Mattermost or Discourse are great open source options) where you could interact with presenters well after their session ended. At an in-person conference, you're often limited to a 10 or 15 minute break after a session to talk to the presenter. Virtual events allow you to have a Q&A channel available for a few days after the event.  This let's both synchronous and asynchronous attendees communicate with presenters.

Best of both worlds

I'm definitely glad that in-person events are back and I'm able to see my open source friends again in real life. However, I don't think we need to completely put virtual events behind us. In particular, hybrid events with "virtual tracks" can make events accessible to more community members and help you reach a wider audience. I think society has learned some important lessons, so let's put them to good use.

Are you interested in leveraging Markdown for online content without any website setup or build process? How about seamlessly embedding constraint-free Markdown or HTML into multiple platforms (such as a content management system or learning management system)? The open source project Docsify-This, built with Docsify.js, provides an easy way to publish, share, and reuse Markdown content.

[ Get the Markdown cheat sheet ]

What is Docsify-This?

With Docsify-This, you can instantly turn any publicly available Markdown file into a responsive standalone web page. You can also link multiple Markdown files to create a simple website. Designers can alter the visual appearance of displayed pages with the point-and-click Web Page Builder interface or URL parameters. You can also use a set of provided Markdown CSS classes when creating your own Markdown content. In addition, if you use Codeberg or GitHub to store your Markdown files, an Edit this Page link can be automatically provided for each page to support collaborative authoring.

It's open source, so you can host a Docsify-This instance using your own custom domain without the risk of platform lock-in.

Use the Docsify-This Web Page Builder

To use the Web Page Builder, open a browser and navigate to the Docsify-This website or your local instance. In the Web Page Builder section, enter the URL of a Markdown file in a public repo of Codeberg or GitHub (other Git hosts can also be used via Docsify-This URL parameters but not in the Web Page Builder), and then click the Publish as Standalone Web Page button.

Image by:

(Paul Hibbitts, CC BY-A 4.0)

The Markdown file is rendered as a standalone web page with a URL you can copy and share. Here's an example URL:

https://docsify-this.net/?basePath=https://raw.githubusercontent.com/hibbitts-design/docsify-this-one-page-article/main&homepage=home.md

Docsify-This rendered web pages are perfect for embedding, with the ability to visually style Docsify-This pages to the destination platform.

Image by:

(Paul Hibbitts, CC BY-A 4.0)

Render other files in the same repository

You can render other Markdown files in the same repository by directly editing the Docsify-This URL parameter homepage. For example:

https://docsify-this.net/?basePath=https://raw.githubusercontent.com/hibbitts-design/docsify-this-one-page-article/main&homepage=anotherfile.md

Modify the web page's appearance

You can change the appearance of any Markdown file displayed in Docsify-This by using URL parameters. For example, font-family, font-size, link-color, and line-height are all common CSS attributes and are valid parameters for Docsify-This:

https://docsify-this.net/?basePath=https://raw.githubusercontent.com/hibbitts-design/docsify-this-one-page-article/main&homepage=home.md&font-family=Open%20Sans,sans-serif

You can also alter the visual appearance using a set of special Markdown CSS classes. For example, you can add the button class to a link:

[Required Reading Quiz due Jun 4th](https://canvas.sfu.ca/courses/44038/quizzes/166553 ':class=button')  

This produces a button image instead of just a text link:

Image by:

(Paul Hibbitts, CC BY-A 4.0)

In addition to the Markdown CSS classes supported by Docsify-This, you can define your own custom classes within your displayed Markdown files. For example:

[Custom CSS Class Button](# ':class=mybutton')

Produces this:

Image by:

(Paul Hibbitts, CC BY-A 4.0)

Include HTML snippets

As supported by standard Markdown, you can include HTML snippets. This allows you to add layout elements to your HTML render. For example:

Lorem ipsum dolor sit amet, consectetur adipiscing elit.




Lorem ipsum dolor sit amet, consectetur adipiscing elit.

Embed Docsify-This as an iFrame

You can embed Docsify-This web pages using an iFrame in almost any platform. You can also use URL parameters to ensure your embedded content matches your destination platform:

Image by:

(Paul Hibbitts, CC BY-A 4.0)

Embed Docsify-This with an external URL

In certain learning management systems (LMS), including the open source Moodle and even the proprietary Canvas, you can link external web pages to a course navigation menu and sometimes more. For example, you can use the Redirect Tool in Canvas to display Docsify-This web pages.

url=https://docsify-this.net/?basePath=https://raw.githubusercontent.com/paulhibbitts/cmpt-363-222-pages/main&homepage=resources.md&edit-link=https://github.com/paulhibbitts/cmpt-363-222-pages/blob/main/resources.md&font-family=Lato%20Extended,Lato,Helvetica%20Neue, Helvetica,Arial,sans-serif&font-size=1&hide-credits=true

Integrate Docsify-This and Git

To fully leverage the benefits of version control and potentially collaboration using an optional Edit this Page link, store your Docsify-This Markdown pages in a Git repository on either Codeberg or GitHub. Several open source tools provide a graphical interface for Git, including GitHub Desktop (recently released as open source), Git-Cola, and SparkleShare. The text editors VSCode and Pulsar Edit (formerly Atom.io) both feature Git integration, too.

[ Get the Git tips and tricks eBook ]

Markdown publishing made easy

The benefits of Markdown-based publishing are available to everyone, thanks to Docsify. And thanks to Docsify-This, it's easier than ever. Try it out at the Docsify-This website.

Your open source project's documentation is essential to your customers. Your target audience must understand the purpose of your project and how to use it, and documentation is what bridges that gap. A project is rarely ever truly done, so it's equally important for resources to be maintained and updated with your project's continuous improvement.

But what happens when you have lots of documentation to maintain but lack the resources to keep it current? The answer is pretty simple: Host a docathon!

What is a docathon?

A docathon is like a hackathon. A hackathon is an event where engineers and community leaders gather to improve or add new features to an existing application. In a docathon, the same kind of collaboration focuses on improving documentation.

[ Learn about writing Docs as Code. ]

A docathon can fill gaps within content, restructure large documentation sets, fix broken links, or just correct typos. The intent behind hosting a docathon is to improve a large amount of documentation in a relatively brief timeframe.

Some examples of product documentation include:

• Training manuals
• User manuals
• Installation guides
• Troubleshooting guides
• Quickstart guides
• API documentation
• Tutorials

At my organization, our documentation team hosted a docathon and successfully revamped a 102-page installation guide. The docathon enabled us to focus on the project's scope, which was reorganizing for simplicity, removing duplicate content, and following the customer journey. Hosting a docathon left a lasting impression on my team and improved customer success.

[ Read Write documentation that actually works for your community ]

3 things you can achieve with a docathon

Here are my top three reasons to host a docathon:

1. No more backlog

Most documentation must evolve along with the product it supports. As the product changes or updates, so must the documentation. In some cases, documentation teams release new versions of their documentation alongside the engineering team's release cycle. As priorities within a team change and GA releases continue, documentation teams face the challenge of keeping up with new features, bug fixes, and tasks to complete. The changes that get left behind become part of a backlog—an accumulation of work that needs to be completed at a later time.

Docathon tip: During a docathon, participants can triage backlog items and complete them as they progress through the list. Non-technical participants can work on fixes related to typos, broken links, and other text-related issues.

2. Revamp large-scale guides

By the time your documentation team realizes it's time to revamp a guide, it's probably several chapters in and hundreds of pages deep. Once the content plan has been developed, the complexity of restructuring begins. Restructuring a large amount of documentation is not for the faint of heart.

Docathon tip: Assemble a team to lead the docathon and provide incentives for organization-wide participation from different teams or departments. Depending on the scope of work and time constraints, your team can successfully restructure an entire guide in less time than you probably expect.

3. Collaboration between cross-functional teams

It is common for different groups within an organization to work in isolation. Engineering, product, customer support, marketing, and documentation teams may not collaborate on projects as often as they should.

Imagine hosting an event where each team member can use their expertise to improve product documentation. Docathons foster subject matter expert (SME) diversity, real-time collaboration, and communication. They also allow for an inclusive environment where individuals residing in different geographical locations can participate in person or remotely. Your documentation receives the undivided attention of experts with different viewpoints and specializations, minimizing isolated siloes, unconscious bias, and burnout.

Docathon tip: Enable cross-functional teams to come together for a common cause.

[ Learn what it takes to build a resilient IT culture ]

Documentation marathon

The next time your team has a seemingly insurmountable backlog or is tasked with restructuring a huge documentation project, consider hosting a docathon. It's easy, and its productivity may surprise you. For more information on hosting an event like this, read Tiffany Long's excellent 10-step guide to hosting a hackathon.

Recently, I was asked by a friend and colleague if I were interested in speaking together at a conference. I was pleasantly surprised because I hadn't contributed much to the project they were presenting, but I expressed interest. We met to discuss the presentation, and that's when I learned the real reason I was asked to participate: The conference's diversity, equity, and inclusion (DEI) initiatives required there to be at least one speaker that does not identify as a man. I was offended; it felt like I was approached only because of my gender, not based on merit.

My friend assured me that wasn't the only reason I'd been asked. They needed new contributors to the project because there was a lot of work to be done, and they were hoping I could help fill that gap.

[ Want to create your own event? Read the 10-step guide for a successful hackathon ]

I gave it some thought and tried to understand why the DEI initiatives were in place.  I also thought about the other side of the coin, where the people who wanted to present couldn't, unless they found someone from a minority group to present alongside them.

As I thought about the bigger picture and the benefits this opportunity would bring to me, I decided to forego my ego being hurt. Once I let go of feeling offended, I realized that I was also feeling very uncomfortable presenting something that I hadn't contributed directly to. My ethics didn't agree with that. How could I possibly step onto a stage and act as the face of something I hadn't worked on?

Resolving to help more

I did some research on the project. The technology was not totally alien to me, and I had a good grasp of the fundamentals it was trying to achieve. In fact, its overall goal made me feel excited to contribute. If done well, it would be super useful to users.

I made a resolution that I would go ahead with this speaking opportunity only if I got the opportunity to give back to the community tenfold and become a key contributor. My friend was more than willing to help me on that journey.

With that resolve, we submitted our talk. My co-presenters were supportive and made me feel welcome. They said that as long as I was interested and had a passion for the project, nothing else mattered.

[ Also read How I returned to open source after facing grief ]

Participating in the conference was a huge opportunity, and it had such a positive impact on me. I met a lot of experienced people across the open source community and I felt inspired! I learned a lot of new things from the people and the various panels, sessions, and discussions at the conference. Our presentation went well, and I consider giving a talk at such a big conference quite an achievement.

However, once the conference was over the guilt started kicking in.

Guilt as a motivator

I felt like I owed the community and the people who had given me this chance. I wanted to focus on the promise I'd made, but it was hard with other higher-priority things getting in the way. Whenever I deviated from my plan, the guilt kept me on track. It reminded me that I had to give back to the community that had given me such a good opportunity. After a few months of struggling and juggling, I can proudly say that I didn't give up. Today, I'm an active contributor to that project.

I love the challenges it presents, and I enjoy solving some of the key issues in the project's area. I also have been able to take the lead in implementing this upstream project in our downstream ecosystem. As icing on the cake, I was again invited to present with the team and give the community updates for the project. This time, it was not because of a DEI initiative, as the ratio was already balanced.

Feeling guilt isn't so bad after all!

I'm glad that I took the opportunity, and I'm glad it turned out to be a win-win situation for everyone involved. If I hadn't been approached about being a co-presenter, I probably would have never gotten involved in this project, and that would have been such a miss! I'm grateful to the people who gave me this chance and supported me.

I'm probably not the only woman who has faced this. I want to tell all the women out there, if such an opportunity presents itself, there's no need to feel guilt, or that you "owe" anyone, or any kind of pressure. If you do feel such pressure, then turn that emotion into a weapon and do good with it!

So that it ties back to the title?... because I am talking about how I turned this guilt as a motivator but also saying don't feel any guilt in the first place,

Also on the other hand, not sure if we should retitle the article to be more of a "DEI opportunities can be uncomfortable at the beginning but have advantages" kind of thing instead? Either ways happy with the article overall!

[ Ready to level up your communication skills? Get advice from IT leaders. Download 10 resources to make you a better communicator. ]

When I go back home and talk to people in the tech industry, or any other industry for that matter, about what I do and the topics I'm involved in daily, I'm usually met with bemusement at the idea of an Open Source Programs Office (OSPO). The concept of a company contributing to an open source project without obvious immediate financial benefit can be culturally strange to understand or explain.

As someone born and raised in a country that has been trying to develop for quite some time, I understand and relate to that. There was a point in time when my only understanding of open source was that it was software that I could use without paying and without needing to wait for a specific issue or additional feature to be released. I could just do whatever I needed myself, locally.

Open source faces many struggles in developing countries that make how it's perceived and its associations inaccurate and out of touch. I will discuss these struggles in this article.

Open source challenges in developing countries

The challenges that open source faces in these regions can be divided into three main areas:

• Society and culture
• Resources and infrastructure
• Governance

Society and culture

It's no secret that the culture of tech in general, and specifically the open source part of it, feeds off the culture of the society where it exists. That's why, in today's world, open source has a better chance of being sustained and maintained in the more developed parts of the world.

But imagine a perfect society, optimal for open source to grow, be sustained, and maintained. What does the culture of that society look like? What are its main characteristics?

Open and transparent

For open source to thrive, the society's culture must be as open and transparent as possible. Information must be freely and publicly accessible, which is a huge issue in many underdeveloped regions. Information is often red-taped and is unavailable to the average citizen, let alone someone who's trying to contribute to open source.

[ Related read Global communication in open source projects ]

Free

The word "free" has many different meanings and implications. There's freedom of speech, expression, choice, belief, religion, and many others. The aspect of freedom I'm most concerned with in this context is the ability to start new communities and organizations without a higher authority intervening. That's the essence of open source. Distributed modes of collaboration, in which large groups work together without a strong centralized authority directing them, are highly effective. This is another major challenge in most of these regions. New communities and organizations are often questioned, closely monitored, and unfortunately, in some cases, even prosecuted and eventually shut down for fear of the new ideas that may emerge or other reasons.

Dynamic

A dynamic culture is essential for the growth of open source. A culture that's ready to accept and implement new ideas is the perfect place for open source to grow. Being resistant to change and preferring to stick with traditional approaches can limit society's willingness to adopt new technologies and solutions, which is a major issue in most underdeveloped countries.

The greatest and most common reason behind resistance to change in these regions is the fear of the unknown. It would be unfair to discuss fear of the unknown as a "developing countries" problem. It's a common issue everywhere, even in the developed world. But some reasons behind this fear are specific to underdeveloped regions. The two main reasons are a lack of trust in the competence of the tech industry and a lack of accountability. Businesses and individuals do not trust the capabilities of the software solutions on offer, let alone open source solutions. There's an idea that open source software is unsafe and insecure. This concern is magnified when people do not trust the competence of the software developers. Second, people do not trust the system to hold anyone accountable for any possible mistakes or issues arising from using the software or in legal conflicts.

Resources, infrastructure, and economy

Economic challenges are the most obvious struggle for open source in developing countries, impacting open source developers and communities in these regions.

Access and funds

Open source developers struggle with issues of accessibility in developing countries. Whether it's access to the internet or equipment, it can be difficult to become a regular open source contributor when you struggle to reach resources daily. The digital divide in these regions is huge. There are still many areas without regular, stable, and high-speed internet connections. There's also a market gap between these regions and the rest of the world when it comes to equipment. There's always the challenge of not having enough funds to buy the latest, most powerful machines, but there's also an availability problem. The modern, powerful tech equipment needed to build and run the biggest open source projects isn't always available in these regions.

These concerns make self-education and learning challenging. It's difficult for an open source developer to pick an open source project, learn all about it on their own, and start contributing to it due to these access issues.

And how do you build an open source community under these circumstances? Projects would end up being maintained by the privileged few with access to stable high-speed internet connections and the latest equipment. The rest would be spotty, occasional contributions from others that can hardly be considered a community. And even those would disappear once the chance of paid work appears. I've personally seen it multiple times. Someone would start learning about an open source project to research a specific stack or improve their skills and begin contributing to it. But once the opportunity of paid work appeared, even as a second job, they dropped the open source project completely. It makes sense. Any individual must prioritize a means of survival for themselves and their family.

This lack of resources and dependence on a privileged few would also make it almost impossible to fund marketing campaigns, community-building events, and, last but not least, documentation localization attempts.

Localization

English is the language of the internet, but not for many these countries. While almost all developers speak English at a basic level, not everyone has the ability to comprehend and understand documentation, architecture resources, and technical specifications to the level that enables them to meaningfully contribute to an open source project. The non-existence of adapted documentation makes it difficult for developers in developing countries to find an entry point into open source projects. The time and resources required to do that usually discourage potential contributors from these regions.

[ Also read How open source weaves connections between countries ]

Employee contracts

Almost all software employee contracts are designed to monetize every single line of code, contribution, or thought the developer might have. Any participation in external projects can be a cause for questioning by the employing company, which all too often discourages developers from contributing to open source to avoid legal issues. Laws favor corporations and organizations and prevent software developers from making external contributions.

Intellectual property laws

Legal frameworks in developing countries are often ill-equipped to handle the nuances of intellectual property rights and open source licensing. Intellectual property laws in developing countries may be weaker or less comprehensive than those in developed countries, and enforcement may be less effective. This can make it difficult for creators and contributors to protect their work and prevent others from using it without permission.

In addition, open source licensing can be complex. Many developing countries may not have the legal expertise or resources to navigate these licenses effectively. This can make it tough for developers to contribute to open source projects without inadvertently violating the terms of the license.

Another issue is that intellectual property laws and open source licensing are sometimes seen as hindrances to innovation and development in developing countries. Critics argue that these laws and licenses can stifle creativity and prevent the spread of knowledge and technology, particularly in areas where access to resources and technology is limited.

Overall, the challenges surrounding intellectual property laws and open source contributions in developing countries are complex and multifaceted, requiring a nuanced approach that accounts for the unique circumstances and challenges these countries face.

Proprietary software deals

Tech giants based in the US and Europe enter into billion-dollar, decades-long deals with governments in developing regions to supply them with software. On the off chance that someone gets elected into a position and decides to start an initiative to adopt open source software, they find that getting out of these deals would cost a fortune.

Open isn't always easy

These are just some of the struggles open source faces in developing countries. There's much to be done to improve the situation and make adopting and growing open source feasible. In future articles, I will delve into specific solutions, but for now, I'll note that, as with everything, it starts with the individual. As we each "crowdsource" an open culture, the culture of the regions where we live and work changes. Bring open source to your community in whatever small way you can, and see where it leads.

The Fedora Design Team discovered that using open source tools to run a virtual conference can be quite effective by hosting the first Creative Freedom Summit in January 2023.

In this article, I'll share some background on the conference, why using open source tools to run it was important to us, and the specific tools and configurations our team used to make it all work. I'll also talk about what worked well and what will need improvement at our next summit in 2024.

What is Creative Freedom Summit?

The Creative Freedom Summit was an idea Marie Nordin came up with after reviewing talk submissions for Flock, the annual Fedora users and contributors conference. She received many talk submissions for the August 2022 Flock relating to design and creativity in open source—far more than we could possibly accept. With so many great ideas for open source design-related talks out there, she wondered if there would be space for a separate open source creativity conference focused on creatives who use open source tools to produce their work.

Marie brought this idea to the Fedora Design Team in the fall of 2022, and we started planning the conference, which took place January 17-19, 2023. Since it was our first time running a new conference like this, we decided to start with invited speakers based on some of the Flock submissions and our own personal network of open source creatives. Almost every speaker we asked gave a talk, so we didn't have room to accept submissions. We will need to figure out this next year, so we don't have an open source CFP (Call for Papers) management tool for that to tell you about yet.

Using open source for open source conferences

Since the initial COVID pandemic lockdowns, Fedora's Flock conference has been run virtually using Hopin, an online conference platform that isn't open source but is friendly to open source tools. Fedora started using it some years ago, and it definitely provides a professional conference feel, with a built-in sponsor booth/expo hall, tracks, hallway chat conversations, and moderation tools. Running the Creative Freedom Summit using Hopin was an option for us because, as a Fedora-sponsored event, we could access Fedora's Hopin setup. Again, Hopin is not open source.

Now, as a long-term (~20 years) open source contributor, I can tell you that this kind of decision is always tough. If your conference focuses on open source, using a proprietary platform to host your event feels a little strange. However, as the scale and complexity of our communities and events have grown, the ability to produce an integrated open source conference system has become more challenging.

There is no right or wrong answer. You have to weigh a lot of things when making this decision:

• Budget
• People power
• Infrastructure
• Technical capability
• Complexity/formality/culture of the event

We didn't have any budget for this event. We did have a team of volunteers who could put some work hours into it. We had the Fedora Matrix Server as a piece of supported infrastructure we could bring into the mix and access to a hosted WordPress system for the website. Teammate Madeline Peck and I had the technical capability/experience of running the live, weekly Fedora Design Team video calls using PeerTube. We wanted the event to be low-key, single-track, and informal, so we had some tolerance for glitches or rough edges. We also all had a lot of passion for trying an open source stack.

Now you know a little about our considerations when making this decision, which might help when making decisions for your event.

An open source conference stack

Here is how the conference tech stack worked.

Overview

Live components

• Livestream: We streamed the stage and the social events to a PeerTube channel. Conference attendees could watch the stream live from our PeerTube channel. PeerTube includes some privacy-minded analytics to track the number of livestream viewers and post-event views.
• Live stage + social event room: We had one live stage for speakers and hosts using Jitsi, ensuring only those with permission could be on camera. We had an additional Jitsi meeting room for social events that allowed anyone who wanted to participate in the social event to go on camera.
• Backstage: We had a "Backstage" Matrix channel to coordinate with speakers, hosts, and volunteers in one place while the event was going on.
• Announcements and Q&A: We managed Q&A and the daily schedule for the conference via a shared Etherpad (which we later moved to Hackmd.io).
• Integrated and centralized conference experience: Using Matrix's Element client, we embedded the livestream video and an Etherpad into a public Matrix room for the conference. We used attendance in the channel to monitor overall conference attendance. We had a live chat throughout the conference and took questions from audience members from the chat and the embedded Q&A Etherpad.
• Conference website: We had a beautifully-designed website created by Ryan Gorley hosted on WordPress, which had the basic information and links for how to join the conference, the dates/times, and the schedule.

Post-event components

• Post-event survey: We used the open source LimeSurvey system to send out a post-event survey to see how things went for attendees. I use some of the data from that survey in this article.
• Post-event video editing and captioning: We didn't have a live captioning system for the conference, but as I was able, I typed live notes from talks into the channel, which attendees greatly appreciated. Post-event, we used Kdenlive (one of the tools featured in talks at the event) to edit the videos and generate captions.
• Event recordings: PeerTube automagically posts livestream recordings to channels, making nearly instant recordings available for attendees for talks they may have missed.

I'll cover some details next.

Livestream with PeerTube

Image by:

(Máirín Duffy, CC BY-SA 4.0)

We used the LinuxRocks PeerTube platform generously hosted by LinuxRocks.online for the Creative Freedom Summit's livestream. PeerTube is a free and open source decentralized video platform that is also part of the Fediverse.

One of the best features of PeerTube (that other platforms I am aware of don't have) is that after your livestream ends, you get a near-instant replay recording posted to your channel on PeerTube. Users in our chatroom cited this as a major advantage of the platform. If an attendee missed a session they were really interested in, they could watch it within minutes of that talk's end. It took no manual intervention, uploading, or coordination on the part of the volunteer organizing team to make this happen; PeerTube automated it for us.

Here is how livestreaming with PeerTube works: You create a new livestream on your channel, and it gives you a livestreaming URL + a key to authorize streaming to the URL. This URL + key can be reused over and over. We configured it so that the recording would be posted to the channel where we created the livestreaming URL as soon as a livestream ended. Next, copy/paste this into Jitsi when you start the livestream. This means that you don't have to generate a new URL + key for each talk during the conference—the overhead of managing that for organizers would have been pretty significant. Instead, we could reuse the same URL + key shared in a common document among conference organizers (we each had different shifts hosting talks). Anyone on the team with access to that document could start the livestream.

How to generate the livestream URL + key in PeerTube

The following section covers generating the livestream URL + key in PeerTube, step-by-step.

1. Create stream video on PeerTube

Log into PeerTube, and click the Publish button in the upper right corner:

Image by:

(Máirín Duffy, CC BY-SA 4.0)

2. Set options

Click on the Go live tab (fourth from the left) and set the following options:

• Channel: (The channel name you want the livestream to publish on)
• Privacy: Public
• Radio buttons: Normal live

Then, select Go Live. (Don't worry, you won't really be going live quite yet, there is more data to fill in.)

Image by:

(Máirín Duffy, CC BY-SA 4.0)

3. Basic info (don't click update yet)

First, fill out the Basic Info tab, then choose the Advanced Settings tab in the next step. Fill out the name of the livestream, description, add tags, categories, license, etc. Remember to publish after the transcoding checkbox is turned on.

This ensures once your livestream ends, the recording will automatically post to your channel.

4. Advanced settings

You can upload a "standby" image that appears while everyone is watching the stream URL and waiting for things to start.

Image by:

(Máirín Duffy, CC BY-SA 4.0)

This is the standby image we used for the Creative Freedom Summit:

Image by:

(Máirín Duffy, CC BY-SA 4.0)

5. Start livestream on PeerTube

Select the Update button in the lower right corner. The stream will appear like this—it's in a holding pattern until you start streaming from Jitsi:

Image by:

(Máirín Duffy, CC BY-SA 4.0)

6. Copy/paste the livestream URL for Jitsi

This is the final step in PeerTube. Once the livestream is up, click on the … icon under the video and towards the right:

Image by:

(Máirín Duffy, CC BY-SA 4.0)

Select Display live information. You'll get a dialog like this:

Image by:

(Máirín Duffy, CC BY-SA 4.0)

You must copy both the live RTMP URL and the livestream key. Combine them into one URL and then copy/paste that into Jitsi.

The following are examples from my test run of these two text blocks to copy:

• Live RTMP Url: rtmp://peertube.linuxrocks.online:1935/live
• Livestream key: 8b940f96-c46d-46aa-81a0-701de3c43c8f

What you'll need to paste into Jitsi is these two text blocks combined with a / between them, like so:

rtmp://peertube.linuxrocks.online:1935/live/8b940f96-c46d-46aa-81a0-701de3c43c8f

Live stage + social event room: Jitsi

We used the free and open source hosted Jitsi Meet video conferencing platform for our "live stage." We created a Jitsi meeting room with a custom URL at https://meet.jit.si and only shared this URL with speakers and meeting organizers.

We configured the meeting with a lobby (this feature is available in meeting settings once you join your newly-created meeting room) so speakers could join a few minutes before their talk without fear of interrupting the presentation before theirs. (Our host volunteers let them in when the previous session finished.) Another option is to add a password to the room. We got by just by having a lobby configured. It did seem, upon testing, that the moderation status in the room wasn't persistent. If a moderator left the room, they appeared to lose moderator status and settings, such as the lobby setup. I kept the Jitsi room available and active for the entire conference by leaving it open on my computer. (Your mileage may vary on this aspect.)

Jitsi has a built-in livestreaming option, where you can post a URL to a video service, and it will stream your video to that service. We had confidence in this approach because it is how we host and livestream weekly Fedora Design Team meetings. For the Creative Freedom Summit, we connected our Jitsi Live Stage (for speakers and hosts) to a channel on the Linux Rocks PeerTube.

Jitsi lets speakers share their screens to drive their own slides or live demos.

Livestreaming Jitsi to PeerTube

1. Join the meeting and click the … icon next to the red hangup button at the bottom of the screen.

Image by:

(Máirín Duffy, CC BY-SA 4.0)

2. Select Start live stream from the pop-up menu.

Image by:

(Máirín Duffy, CC BY-SA 4.0)

3. Copy/paste the PeerTube URL + key text

Image by:

(Máirín Duffy, CC BY-SA 4.0)

4. Listen for your Jitsi Robot friend

A feminine voice will come on in a few seconds to tell you, "Live streaming is on." Once she sounds, smile! You're livestreaming.

5. Stop the livestream

This stops the PeerTube URL you set up from working, so repeat these steps to start things back up.

Jitsi tips

Managing Recordings by turning the Jitsi stream on and off

We learned during the conference that it is better to turn the Jitsi stream off between talks so that you will have one raw recording file per talk posted to PeerTube. We let it run as long as it would the first day, so some recordings have multiple presentations in the same video, which made using the instant replay function harder for folks trying to catch up. They needed to seek inside the video to find the talk they wanted to watch or wait for us to post the edited version days or weeks later.

Preventing audio feedback

Another issue we figured out live during the event that didn't crop up during our tests was audio feedback loops. These were entirely my fault (sorry to everyone who attended). I was setting up the Jitsi/PeerTube links, monitoring the streams, and helping host and emcee the event. Even though I knew that once we went live, I needed to mute any PeerTube browser tabs I had open, I either had more PeerTube tabs open than I thought and missed one, or the livestream would autostart in my Element client (which I had available to monitor the chat). I didn't have an easy way to mute Element. In some of the speaker introductions I made, you'll see that I knew I had about 30 seconds before the audio feedback would start, so I gave very rushed/hurried intros.

I think there are simpler ways to avoid this situation:

• Try to ensure your host/emcee is not also the person setting up/monitoring the streams and chat. (Not always possible, depending on how many volunteers you have at any given time.)
• If possible, monitor the streams on one computer and emcee from another. This way, you have one mute button to hit on the computer you're using for monitoring, and it simplifies your hosting experience on the other.

This is something worth practicing and refining ahead of time.

Backstage: Element

Image by:

(Máirín Duffy, CC BY-SA 4.0)

We set up a "Backstage" invite-only chat room a week or so before the conference started and invited all our speakers to it. This helped us ensure a couple of things:

• Our speakers were onboarded to Element/Matrix well before the event's start and had the opportunity to get help signing up if they had any issues (nobody did).
• We started a live communication channel with all speakers before the event so that we could send announcements/updates pretty easily.

The channel served as a useful place during the event to coordinate transitions between speakers, give heads up about whether the schedule was running late, and in one instance, quickly reschedule a talk when one of our speakers had an emergency and couldn't make their original scheduled time.

We also set up a room for hosts, but in our case, it was extraneous. We just used the backstage channel to coordinate. We found two channels were easy to monitor, but three were too many to be convenient.

Announcements and Q&A: Etherpad/Hackmd.io

Image by:

(Máirín Duffy, CC BY-SA 4.0)

We set up a pinned widget in our main Element channel with general information about the event, including the daily schedule, code of conduct, etc. We also had a section per talk of the day for attendees to drop questions for Q&A, which the host read out loud for the speaker.

We found over the first day or two that some attendees were having issues with the Etherpad widget not loading, so we switched to an embedded hackmd.io document pinned to the channel as a widget, and that seemed to work a little better. We're not 100% sure what was going on with the widget loading issues, but we were able to post a link to the raw (non-embedded) link in the channel topic, so folks could get around any problems accessing it via the widget.

Integrated and centralized conference experience

Image by:

(Máirín Duffy, CC BY-SA 4.0)

Matrix via Fedora's Element server was the single key place to go to attend the conference. Matrix chat rooms in Element have a widget system that allows you to embed websites into the chat room as part of the experience. That functionality was important for having our Matrix chat room serve as the central place to attend.

We embedded the PeerTube livestream into the channel—you can see it in the screenshot above in the upper left. Once the conference was over, we could share a playlist of the unedited video replays playlist. Now that our volunteer project for editing the videos is complete, the channel has the playlist of edited talks in order.

As discussed in the previous section, we embedded a hackmd.io note in the upper right corner to post the day's schedule, post announcements, and an area for Q&A right in the pad. I had wanted to set up a Matrix bot to handle Q&A, but I struggled to get one running. It might make for a cool project for next year, though.

Conversations during the conference occurred right in the main chat under these widgets.

There are a couple of considerations to make when using a Matrix/Element chat room as the central place for an online conference, such as:

• The optimal experience will be in the Element desktop client or a web browser on a desktop system. However, you can view the widgets in the Element mobile client (although some attendees struggled to discover this, the UI is less-than-obvious). Other Matrix clients may not be able to view the widgets.
• Attendees can easily DIY their own experience piecemeal if desired. Users not using the Element client to attend the conference reported no issues joining in on the chat and viewing the PeerTube livestream URL directly. We shared the livestream URL and the hackmd URL in the channel topic, making it accessible to folks who preferred not to run Element.

Website

Image by:

(Máirín Duffy, CC BY-SA 4.0)

Ryan Gorley developed the Creative Freedom Summit website using WordPress. It is hosted by WPengine and is a one-pager with the conference schedule embedded from sched.org.

Post-event

Post-event survey

We used the open source survey tool LimeSurvey. We sent it out within a week or two to attendees via the Element Chat channel and our PeerTube video channel to learn more about how we handled the event. The event organizers continue to meet regularly. One topic we focus on during these post-event meetings is developing the questions for the survey in a shared hackmd.io document. The following are some things we learned from the event that might be of interest to you in planning your own open source powered online conference:

• By far, most event attendees learned about the event from Mastodon and Twitter (together, covering 70% of respondents).
• 33% of attendees used the Element desktop app to attend, and 30% used the Element Chat web app. So roughly 63% of attendees used the integrated Matrix/Element experience. The rest watched directly on PeerTube or viewed replays after.
• 35% of attendees indicated they made connections with other creatives at the event via the chat, so the chat experience is pretty important to events if part of your goal is enabling networking and connections.

Captioning

During the event, we received positive feedback from participants who appreciated when another attendee live-captioned the talk in the chat and wished out loud for live captioning for better accessibility. While the stack outlined here did not include live captioning, there are open source solutions for it. One such tool is Live Captions, and Seth Kenlon covered it in an opensource.com article, Open source video captioning on Linux. While this tool is meant for the attendee consuming the video content locally, we could potentially have a conference host running it and sharing it to the livestream in Jitsi. One way to do this is using the open source broadcasting tool OBS so everyone watching the livestream could benefit from the captions.

While editing the videos post-event, we discovered a tool built into Kdenlive, our open source video editor of choice, that generates and automatically places subtitles in the videos. There are basic instructions on how to do this in the Kdenlive manual. Fedora Design Team member Kyle Conway, who helped with the post-event video editing, put together a comprehensive tutorial (including video instruction) on automatically generating and adding subtitles to videos in Kdenlive. It is well worth the read and watch if you are interested in this feature.

Video editing volunteer effort

When the event was over, we rallied a group of volunteers from the conference Element channel to work together on editing the videos, including title cards and intro/outro music, and general cleanup. Some of our automatic replay recordings were split across two files or combined in one file with multiple other talks and needed to be reassembled or cropped down.

We used a GitLab epic to organize the work, with an FAQ and call for volunteer help organized by skillset, with issues attached for each video needed. We had a series of custom labels we would set on each video so it was clear what state the video was in and what kind of help was needed. All the videos have been edited, and some need content written for their description area on the Creative Freedom Summit channel. Many have auto-generated subtitles that have not been edited for spelling mistakes and other corrections common with auto-generated text.

Image by:

(Máirín Duffy, CC BY-SA 4.0)

We passed the videos around—the files could be quite large—by having volunteers download the raw video from the unedited recording on the main PeerTube channel for the Creative Freedom Summit. When they had an edited video ready to share, we had a private PeerTube account where they could upload it. Admins with access to the main channel's account periodically grabbed videos from the private account and uploaded them to the main account. Note that PeerTube doesn't have a system where multiple accounts have access to the same channel, so we had to engage in a bit of password sharing, which can be nerve-wracking. We felt this was a reasonable compromise to limit how many people had the main password but still enable volunteers to submit edited videos without too much hassle.

Ready to give it a try?

I hope this comprehensive description of how we ran the Creative Freedom Summit conference using an open source stack of tools inspires you to try it for your open source event. Let us know how it goes, and feel free to reach out if you have questions or suggestions for improvement! Our channel is at: https://matrix.to/#/#creativefreedom:fedora.im

This article is adapted from Run an open source-powered virtual conference and is republished with permission.

Ideally, designers have a good relationship with their product team and users. However, the relationship between designers and developers is more difficult to build and maintain. The lack of a close relationship makes it difficult to solve problems or improve.

In my experience, the open source Open Decision Framework can overcome many of these obstacles.

The Open Decision Framework asserts that open decision-making is transparent, inclusive, and customer-centric. It involves clearly sharing problems, requirements, and constraints with affected parties. It enables collaboration with multiple stakeholders to secure diverse opinions and comprehensive feedback. Most importantly, it manages relationships and expectations across competing needs and priorities.

These principles probably resonate with anyone involved in the many decisions around designing a product, feature, or service. For a designer, developers are key stakeholders in making the best design decisions. If you're a designer, it's time to embrace the opportunity to get diverse opinions.

The backend and the user experience

Developers are key stakeholders because a user's product or service experience is more than just the pixels on the screen or the workflow designs. It encompasses the service's performance, the speediness of API calls, the way user data is treated, and even the design of the data for scalability. When they're considered full stakeholders in the design, developers can contribute their expertise on the backend and architecture of services to assist the overall design of the experience.

A user experience (UX) designer is a stakeholder for the items the dev team is responsible for. A performance deficit, or the effects of an architecture on what data is available, can hinder the user experience. An open, collaborative relationship between dev and design allows for trust and transparency in all areas.

Make space for collaboration

An open and transparent relationship between developers and design is not as common as it should be. This way of working may be new to both sides. Here are my top five tips for making collaboration a success:

1. Set up a recurring time to collaborate: Establish a recurring time for design and development to meet between once a week and once a month. The invitation should at least include UX, lead engineering, and quality engineering. Ideally, all developers on the team should be invited to attend as schedules permit.

2. Make sharing the main agenda: UX should share the current use cases and features they are working on, along with any relevant user research data. UX designers should demonstrate workflow designs, wireframes, and high-fidelity mockups to the development team. Development should share any design decisions made on their side that may affect how the user experience works.

3. Encourage questions: Collaboration is the ideal scenario. Encourage all attendees to ask questions and give feedback. Answers to questions and responses to feedback are opportunities to discuss design and direction, as well as a chance to learn from one another.

4. Embrace a learning mindset: Avoid lecturing or "telling." Instead, aim to learn from each other. Use mutual expertise to design and build a great experience for users and customers. Ask for explanations of unfamiliar technology or concepts.

5. Consider formal learning: A collaborative relationship can be easier when groups speak the same language. Consider formal learning paths, such as:

   • Designers: A coding foundations course, such as the open source Odin Project, can be helpful for learning the fundamentals of how a service is constructed and built.
   • Developers: An understanding of UX principles can help guide questions and feedback. You can find a good overview at UX design principles or in various books and articles.

An example of open collaboration

In an early design review with a developer on my team, I showed a specific interaction for displaying more data about an object. I communicated the user's need and demonstrated the interaction when the developer asked, "Does it need to be done in exactly this way?"

He mentioned that with a few minor design changes, the effort to develop it would be significantly lower. We agreed that the changes would not negatively affect the user experience, and the user would still be able to achieve their goals.

This feedback saved the development team time, leaving more opportunity to address bugs, build additional features, and preserve a healthy work-life balance. The user experience remained strong, and the team was even stronger. This result would not have been possible without the early feedback from a developer with whom I had a strong working relationship.

Your next steps

Creating an experience is a series of decisions made by a collaborative team. Product, design, and development need to work together as experts in their respective fields and stakeholders in the others. I encourage you to engage development and design for more collaborative feedback and work together to create the best product with the best user experience.

If you don't include tests in your Drupal development, chances are it's because you think it adds complexity and expense without benefit. Cypress is an open source tool with many benefits:

• Reliably tests anything that runs in a web browser
• Works on any web platform (it's great for testing projects using front-end technologies like React)
• Highly extensible
• Increasingly popular
• Easy to learn and implement
• Protects against regression as your projects become more complex
• Can make your development process more efficient

This article covers three topics to help you start testing your Drupal project using Cypress:

1. Installing Cypress
2. Writing and running basic tests using Cypress
3. Customizing Cypress for Drupal

Install Cypress

For the purposes of this tutorial I'm assuming that you have built a local dev environment for your Drupal project using the `drupal/recommended-project` project. Although details on creating such a project are outside of the scope of this piece, I recommend Getting Started with Lando and Drupal 9.

Your project has at least this basic structure:

vendor/
web/
.editorconfig
.gitattributes
composer.json
composer.lock

The cypress.io site has complete installation instructions for various environments. For this article, I installed Cypress using npm.

Initialize your project using the command npm init. Answer the questions that Node.js asks you, and then you will have a package.json file that looks something like this:

{
  "name": "cypress",
  "version": "1.0.0",
  "description": "Installs Cypress in a test project.",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Install Cypress in your project:

$ npm install cypress --save-dev

Run Cypress for the first time:

$ npx cypress open

Because you haven't added a config or any scaffolding files to Cypress, the Cypress app displays the welcome screen to help you configure the project. To configure your project for E2E (end-to-end) testing, click the Not Configured button for E2E Testing. Cypress adds some files to your project:

cypress/
node_modules/
vendor/ 
web/
.editorconfig
.gitattributes
composer.json
composer.lock
cypress.config.js
package-lock.json
package.json

Click Continue and choose your preferred browser for testing. Click Start E2E Testing in [your browser of choice]. I'm using a Chromium-based browser for this article.

In a separate window, a browser opens to the Create your first spec page:

Image by:

(Jordan Graham, CC BY-SA 4.0)

Click on the Scaffold example specs button to create a couple of new folders with example specs to help you understand how to use Cypress. Read through these in your code editor, and you'll likely find the language (based on JavaScript) intuitive and easy to follow.

Click on any in the test browser. This reveals two panels. On the left, a text panel shows each step in the active spec. On the right, a simulated browser window shows the actual user experience as Cypress steps through the spec.

Open the cypress.config.js file in your project root and change it as follows:

const { defineConfig } = require("cypress");
 
module.exports = defineConfig({
  component: {
    fixturesFolder: "cypress/fixtures",
    integrationFolder: "cypress/integration",
    pluginsFile: "cypress/plugins/index.js",
    screenshotsFolder: "cypress/screenshots",
    supportFile: "cypress/support/e2e.js",
    videosFolder: "cypress/videos",
    viewportWidth: 1440,
    viewportHeight: 900,
  },

  e2e: {
    setupNodeEvents(on, config) {
      // implement node event listeners here
    },
    baseUrl: "https://[your-local-dev-url]",
    specPattern: "cypress/**/*.{js,jsx,ts,tsx}",
    supportFile: "cypress/support/e2e.js",
    fixturesFolder: "cypress/fixtures"
   },
 });

Change the baseUrl to your project's URL in your local dev environment.

These changes tell Cypress where to find its resources and how to find all of the specs in your project.

Write and run basic tests using Cypress

Create a new directory called integration in your /cypress directory. Within the integration directory, create a file called test.cy.js:

cypress/
├─ e2e/
├─ fixtures/
├─ integration/ 
│  ├─ test.cy.js
├─ support/ 
node_modules/
vendor/
web/
.editorconfig
.gitattributes
composer.json
composer.lock
cypress.config.js
package-lock.json
package.json

Add the following contents to your test.cy.js file:

describe('Loads the front page', () => {
  it('Loads the front page', () => {
    cy.visit('/')
    cy.get('h1.page-title')
      .should('exist')
  });
});
 
describe('Tests logging in using an incorrect password', () => {
  it('Fails authentication using incorrect login credentials', () => {
    cy.visit('/user/login')
    cy.get('#edit-name')
      .type('Sir Lancelot of Camelot')
    cy.get('#edit-pass')
      .type('tacos')
    cy.get('input#edit-submit')
      .contains('Log in')
      .click()
    cy.contains('Unrecognized username or password.')
  });
});

When you click on test.cy.js in the Cypress application, watch each test description on the left as Cypress performs the steps in each describe() section.

This spec demonstrates how to tell Cypress to navigate your website, access HTML elements by ID, enter content into input elements, and submit the form. This process is how I discovered that I needed to add the assertion that the element contains the text Log in before the input was clickable. Apparently, the flex styling of the submit input impeded Cypress' ability to "see" the input, so it couldn't click on it. Testing really works!

Customize Cypress for Drupal

You can write your own custom Cypress commands, too. Remember the supportFile entry in the cypress.config.js file? It points to a file that Cypress added, which in turn imports the ./commands files. Incidentally, Cypress is so clever that when importing logic or data fixtures, you don't need to specify the file extension, so you import ./commands, not ./commands.js. Cypress looks for any of a dozen or so popular file extensions and understands how to recognize and parse each of them.

Enter commands into commands.js to define them:

/**
 * Logs out the user.
 */
 
Cypress.Commands.add('drupalLogout', () => {
  cy.visit('/user/logout');
})
 
/**
 * Basic user login command. Requires valid username and password.
 *
 * @param {string} username
 *   The username with which to log in.
 * @param {string} password
 *   The password for the user's account.
 */
 
Cypress.Commands.add('loginAs', (username, password) => {
  cy.drupalLogout();
  cy.visit('/user/login');
  cy.get('#edit-name')
    .type(username);
  cy.get('#edit-pass').type(password, {
    log: false,
  });
 
  cy.get('#edit-submit').contains('Log in').click();
});

This example defines a custom Cypress command called drupalLogout(), which you can use in any subsequent logic, even other custom commands. To log a user out, call cy.drupalLogout(). This is the first event in the custom command loginAs to ensure that Cypress is logged out before attempting to log in as a specific user.

Using environment variables, you can even create a Cypress command called drush(), which you can use to execute Drush commands in your tests or custom commands. Look at how simple this makes it to define a custom Cypress command that logs a user in using their UID:

/**
* Logs a user in by their uid via drush uli.
*/
 
Cypress.Commands.add('loginUserByUid', (uid) => {
 cy.drush('user-login', [], { uid, uri: Cypress.env('baseUrl') })
   .its('stdout')
   .then(function (url) {
     cy.visit(url);
   });
});

This example uses the drush user-login command (drush uli for short) and takes the authenticated user to the site's base URL.

Consider the security benefit of never reading or storing user passwords in your testing. Personally, I find it amazing that a front-end technology like Cypress can execute Drush commands, which I've always thought of as being very much on the back end.

Testing, testing

There's a lot more to Cypress, like fixtures (files that hold test data) and various tricks for navigating the sometimes complex data structures that produce a website's user interface. For a look into what's possible, watch the Cypress Testing for Drupal Websites webinar, particularly the section on fixtures that begins at 18:33. That webinar goes into greater detail about some interesting use cases, including an Ajax-enabled form. Once you start using it, feel free to use or fork Aten's public repository of Cypress Testing for Drupal.

Happy testing!

This article originally appeared on the Aten blog and is republished with permission.

Sometimes, a function is called with bad inputs or in a bad program state, so it fails. In languages like Python, this usually results in an exception.

But sometimes exceptions are caused by different issues or are transitory. Imagine code that must keep working in the face of caching data being cleaned up. In theory, the code and the cleaner could carefully agree on the clean-up methodology to prevent the code from trying to access a non-existing file or directory. Unfortunately, that approach is complicated and error-prone. However, most of these problems are transitory, as the cleaner will eventually create the correct structures.

Even more frequently, the uncertain nature of network programming means that some functions that abstract a network call fail because packets were lost or corrupted.

A common solution is to retry the failing code. This practice allows skipping past transitional problems while still (eventually) failing if the issue persists. Python has several libraries to make retrying easier. This is a common "finger exercise."

Tenacity

One library that goes beyond a finger exercise and into useful abstraction is tenacity. Install it with pip install tenacity or depend on it using a dependencies = tenacity line in your pyproject.toml file.

Set up logging

A handy built-in feature of tenacity is support for logging. With error handling, seeing log details about retry attempts is invaluable.

To allow the remaining examples display log messages, set up the logging library. In a real program, the central entry point or a logging configuration plugin does this. Here's a sample:

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s:%(name)s:%(levelname)s:%(message)s",
)

TENACITY_LOGGER = logging.getLogger("Retrying")

Selective failure

To demonstrate the features of tenacity, it's helpful to have a way to fail a few times before finally succeeding. Using unittest.mock is useful for this scenario.

from unittest import mock

thing = mock.MagicMock(side_effect=[ValueError(), ValueError(), 3])

If you're new to unit testing, read my article on mock.

Before showing the power of tenacity, look at what happens when you implement retrying directly inside a function. Demonstrating this makes it easy to see the manual effort using tenacity saves.

def useit(a_thing):
    for i in range(3):
        try:
            value = a_thing()
        except ValueError:
            TENACITY_LOGGER.info("Recovering")
            continue
        else:
            break
    else:
        raise ValueError()
    print("the value is", value)

The function can be called with something that never fails:

>>> useit(lambda: 5)
the value is 5

With the eventually-successful thing:

>>> useit(thing)

2023-03-29 17:00:42,774:Retrying:INFO:Recovering
2023-03-29 17:00:42,779:Retrying:INFO:Recovering

the value is 3

Calling the function with something that fails too many times ends poorly:

try:
    useit(mock.MagicMock(side_effect=[ValueError()] * 5 + [4]))
except Exception as exc:
    print("could not use it", repr(exc))

The result:

2023-03-29 17:00:46,763:Retrying:INFO:Recovering
2023-03-29 17:00:46,767:Retrying:INFO:Recovering
2023-03-29 17:00:46,770:Retrying:INFO:Recovering

could not use it ValueError()

Simple tenacity usage

For the most part, the function above was retrying code. The next step is to have a decorator handle the retrying logic:

import tenacity

my_retry=tenacity.retry(
    stop=tenacity.stop_after_attempt(3),
    after=tenacity.after_log(TENACITY_LOGGER, logging.WARNING),
)

Tenacity supports a specified number of attempts and logging after getting an exception.

The useit function no longer has to care about retrying. Sometimes it makes sense for the function to still consider retryability. Tenacity allows code to determine retryability by itself by raising the special exception TryAgain:

@my_retry
def useit(a_thing):
    try:
        value = a_thing()
    except ValueError:
        raise tenacity.TryAgain()
    print("the value is", value)

Now when calling useit, it retries ValueError without needing custom retrying code:

useit(mock.MagicMock(side_effect=[ValueError(), ValueError(), 2]))

The output:

2023-03-29 17:12:19,074:Retrying:WARNING:Finished call to '__main__.useit' after 0.000(s), this was the 1st time calling it.
2023-03-29 17:12:19,080:Retrying:WARNING:Finished call to '__main__.useit' after 0.006(s), this was the 2nd time calling it.

the value is 2

Configure the decorator

The decorator above is just a small sample of what tenacity supports. Here's a more complicated decorator:

my_retry = tenacity.retry(
    stop=tenacity.stop_after_attempt(3),
    after=tenacity.after_log(TENACITY_LOGGER, logging.WARNING),
    before=tenacity.before_log(TENACITY_LOGGER, logging.WARNING),
    retry=tenacity.retry_if_exception_type(ValueError),
    wait=tenacity.wait_incrementing(1, 10, 2),
    reraise=True
)

This is a more realistic decorator example with additional parameters:

• before: Log before calling the function
• retry: Instead of only retrying TryAgain, retry exceptions with the given criteria
• wait: Wait between calls (this is especially important if calling out to a service)
• reraise: If retrying failed, reraise the last attempt's exception

Now that the decorator also specifies retryability, remove the code from useit:

@my_retry
def useit(a_thing):
    value = a_thing()
    print("the value is", value)

Here's how it works:

useit(mock.MagicMock(side_effect=[ValueError(), 5]))

The output:

2023-03-29 17:19:39,820:Retrying:WARNING:Starting call to '__main__.useit', this is the 1st time calling it.
2023-03-29 17:19:39,823:Retrying:WARNING:Finished call to '__main__.useit' after 0.003(s), this was the 1st time calling it.
2023-03-29 17:19:40,829:Retrying:WARNING:Starting call to '__main__.useit', this is the 2nd time calling it.


the value is 5

Notice the time delay between the second and third log lines. It's almost exactly one second:

>>> useit(mock.MagicMock(side_effect=[5]))

2023-03-29 17:20:25,172:Retrying:WARNING:Starting call to '__main__.useit', this is the 1st time calling it.

the value is 5

With more detail:

try:
    useit(mock.MagicMock(side_effect=[ValueError("detailed reason")]*3))
except Exception as exc:
    print("retrying failed", repr(exc))

The output:

2023-03-29 17:21:22,884:Retrying:WARNING:Starting call to '__main__.useit', this is the 1st time calling it.
2023-03-29 17:21:22,888:Retrying:WARNING:Finished call to '__main__.useit' after 0.004(s), this was the 1st time calling it.
2023-03-29 17:21:23,892:Retrying:WARNING:Starting call to '__main__.useit', this is the 2nd time calling it.
2023-03-29 17:21:23,894:Retrying:WARNING:Finished call to '__main__.useit' after 1.010(s), this was the 2nd time calling it.
2023-03-29 17:21:25,896:Retrying:WARNING:Starting call to '__main__.useit', this is the 3rd time calling it.
2023-03-29 17:21:25,899:Retrying:WARNING:Finished call to '__main__.useit' after 3.015(s), this was the 3rd time calling it.

retrying failed ValueError('detailed reason')

Again, with KeyError instead of ValueError:

try:
    useit(mock.MagicMock(side_effect=[KeyError("detailed reason")]*3))
except Exception as exc:
    print("retrying failed", repr(exc))

The output:

2023-03-29 17:21:37,345:Retrying:WARNING:Starting call to '__main__.useit', this is the 1st time calling it.

retrying failed KeyError('detailed reason')

Separate the decorator from the controller

Often, similar retrying parameters are needed repeatedly. In these cases, it's best to create a retrying controller with the parameters:

my_retryer = tenacity.Retrying(
    stop=tenacity.stop_after_attempt(3),
    after=tenacity.after_log(TENACITY_LOGGER, logging.WARNING),
    before=tenacity.before_log(TENACITY_LOGGER, logging.WARNING),
    retry=tenacity.retry_if_exception_type(ValueError),
    wait=tenacity.wait_incrementing(1, 10, 2),
    reraise=True
)

Decorate the function with the retrying controller:

@my_retryer.wraps
def useit(a_thing):
    value = a_thing()
    print("the value is", value)

Run it:

>>> useit(mock.MagicMock(side_effect=[ValueError(), 5]))

2023-03-29 17:29:25,656:Retrying:WARNING:Starting call to '__main__.useit', this is the 1st time calling it.
2023-03-29 17:29:25,663:Retrying:WARNING:Finished call to '__main__.useit' after 0.008(s), this was the 1st time calling it.
2023-03-29 17:29:26,667:Retrying:WARNING:Starting call to '__main__.useit', this is the 2nd time calling it.

the value is 5

This lets you gather the statistics of the last call:

>>> my_retryer.statistics

{'start_time': 26782.847558759,
 'attempt_number': 2,
 'idle_for': 1.0,
 'delay_since_first_attempt': 0.0075125470029888675}

Use these statistics to update an internal statistics registry and integrate with your monitoring framework.

Extend tenacity

Many of the arguments to the decorator are objects. These objects can be objects of subclasses, allowing deep extensionability.

For example, suppose the Fibonacci sequence should determine the wait times. The twist is that the API for asking for wait time only gives the attempt number, so the usual iterative way of calculating Fibonacci is not useful.

One way to accomplish the goal is to use the closed formula:

A little-known trick is skipping the subtraction in favor of rounding to the closest integer:

Which translates to Python as:

int(((1 + sqrt(5))/2)**n / sqrt(5) + 0.5)

This can be used directly in a Python function:

from math import sqrt

def fib(n):
    return int(((1 + sqrt(5))/2)**n / sqrt(5) + 0.5)

The Fibonacci sequence counts from 0 while the attempt numbers start at 1, so a wait function needs to compensate for that:

def wait_fib(rcs):
    return fib(rcs.attempt_number - 1)

The function can be passed directly as the wait parameter:

@tenacity.retry(
    stop=tenacity.stop_after_attempt(7),
    after=tenacity.after_log(TENACITY_LOGGER, logging.WARNING),
    wait=wait_fib,
)
def useit(thing):
    print("value is", thing())
try:
    useit(mock.MagicMock(side_effect=[tenacity.TryAgain()] * 7))
except Exception as exc:
    pass

Try it out:

2023-03-29 18:03:52,783:Retrying:WARNING:Finished call to '__main__.useit' after 0.000(s), this was the 1st time calling it.
2023-03-29 18:03:52,787:Retrying:WARNING:Finished call to '__main__.useit' after 0.004(s), this was the 2nd time calling it.
2023-03-29 18:03:53,789:Retrying:WARNING:Finished call to '__main__.useit' after 1.006(s), this was the 3rd time calling it.
2023-03-29 18:03:54,793:Retrying:WARNING:Finished call to '__main__.useit' after 2.009(s), this was the 4th time calling it.
2023-03-29 18:03:56,797:Retrying:WARNING:Finished call to '__main__.useit' after 4.014(s), this was the 5th time calling it.
2023-03-29 18:03:59,800:Retrying:WARNING:Finished call to '__main__.useit' after 7.017(s), this was the 6th time calling it.
2023-03-29 18:04:04,806:Retrying:WARNING:Finished call to '__main__.useit' after 12.023(s), this was the 7th time calling it.

Subtract subsequent numbers from the "after" time and round to see the Fibonacci sequence:

intervals = [
    0.000,
    0.004,
    1.006,
    2.009,
    4.014,
    7.017,
    12.023,
]
for x, y in zip(intervals[:-1], intervals[1:]):
    print(int(y-x), end=" ")

Does it work? Yes, exactly as expected:

0 1 1 2 3 5 

Wrap up

Writing ad-hoc retry code can be a fun distraction. For production-grade code, a better choice is a proven library like tenacity. The tenacity library is configurable and extendable, and it will likely meet your needs.

I use GNOME as my primary desktop environment on my Linux PC at home. GNOME gives me an easy-to-use graphical desktop that provides the flexibility I need yet doesn't get in my way when I focus on my work.

GNOME recently released GNOME 44 with a bunch of new features. I reached out to the GNOME team to ask about the latest version and what was in it. Here's what team members Caroline Henriksen (brand manager), Matthias Clasen (GNOME developer and release team member), and Allan Day (design team) had to share.

New GNOME features

Jim Hall: What are some of the new and updated features in GNOME 44 that you're most excited about?

GNOME Team: I am very excited to see how fresh and modern our user interfaces look. Not just in the core apps like Files (the file manager, Nautilus) but also in our Settings, which have seen a lot of work in the last cycle—many Settings panels have been improved. If you have a chance, you should try the new Mouse & Touchpad panel and enjoy the animated illustrations.

There's a lot to like in GNOME 44. For example, I think that a lot of people are going to be really happy about the new grid view in the file chooser, as well as being able to easily connect devices from the new Bluetooth menu in the quick settings.

Jim: The release notes mention GNOME Circle and that a few new apps have been added. What is GNOME Circle?

Team: GNOME Circle is a collection of fantastic apps that use the GNOME platform. It's GNOME's way of promoting the best apps that use our technologies and supporting app developers.

To be included in GNOME Circle, an app has to meet a set of requirements. Once it does, the developers get things like extra publicity and GNOME Foundation membership. That, in turn, gives them access to additional infrastructure and travel sponsorship. More information and how to apply can be found on the GNOME Circle page.

We're thrilled with how successful GNOME Circle has been. It contains more than 50 apps now! I particularly like that not all of these apps revolve around computing. You can find apps like a health tracker, a metronome, or a chess clock.

Jim: GNOME is the standard desktop in several Linux distributions. Where can we expect to see GNOME 44?

Team: The upcoming Fedora 38 release will include GNOME 44 and should be out sometime in April, as will Ubuntu 23.04. And GNOME 44 builds have already landed in openSUSE's Tumbleweed and MicroOS, to name just a few of the major distros.

The GNOME community

Jim: The release name for GNOME 44 is Kuala Lumpur. Where does this name come from?

Team: GNOME has two major yearly conferences, GUADEC in the middle of the year (the next conference will take place in Latvia in July 2023) and GNOME Asia towards the end of the year. We are very thankful to the local team in Malaysia who welcomed us for GNOME Asia 2022 in Kuala Lumpur.

Organizing these events takes a lot of effort and commitment from the GNOME staff and the local teams. As a small sign of our appreciation, GNOME releases are named after the location of the most recent conference. This naming scheme was introduced a number of years ago. GNOME 3.18, Gothenburg, was the first.

Jim: GNOME has a strong user community with active members. How does GNOME keep the community so engaged?

Team: GNOME has always been a community-driven project with a strong sense of collaboration and inclusivity. That's part of what makes being a GNOME contributor and user so rewarding. Being a member of the GNOME community means that you get to interact with people from all over the world to work on common goals and exchange ideas. It is an enriching and inspiring experience, and I think that is what helps keep our community excited and engaged.

One important aspect of fostering that engagement is meeting our community where they're at and making our events more accessible to people from all over the world. For example, our flagship conference, GUADEC, was hosted in Guadalajara, Mexico, last year. This was the first time GUADEC happened outside of Europe, and this helped make it easier for GNOME users and contributors in Latin America to attend.

We also make an effort to meet our community members not just online and at our own conferences but at other events such as Linux Application Summit, FOSDEM, or SCaLE. If you see a GNOME booth at any of these events, please stop by and say hi. You'll often find developers, designers, foundation staff, and board members all happy to chat and answer questions.

Get involved with GNOME

Jim: How can folks get started with writing their own apps for GNOME? If I wanted to learn how to write my first "hello world" app for GNOME, is there a tutorial I can follow?

Team: The Get started developing for GNOME site includes a collection of tutorials, including a guide on quickly creating your first app. With new technologies like Flatpak and GNOME Builder, it's amazing just how easy it is to create your own app nowadays. Fire up Builder, click "new project," fill in some details, and you'll have your own running GNOME app. It really is that easy.

Jim: What are some ways that people can contribute?

Team: If someone is interested in GNOME and is motivated to get involved, there are definitely things they can do to help. Participating in discussions on our Discourse instance or reporting issues is a great place to start if you're a beginner. There are also lots of non-technical jobs that need doing, like helping with our documentation, translating GNOME into different languages, or even helping organize our annual conferences. A lot of these activities have friendly teams working on them who will help you to get started.

Alternatively, if you have coding experience, you can browse our "newcomer" tickets for tasks that might interest you.

Another way to contribute is through donating to GNOME. As an open source project and a non-profit foundation, regular donations help us continue to build up GNOME, provide necessary infrastructure, and power new initiatives.

[ Get the guide to installing applications on Linux ]

Go is a modern programming language that derives much of its history from the C programming language. As such, Go is likely to feel familiar to anyone who writes programs in C. Go makes it easy to write new programs while feeling familiar to C programmers but avoiding many of the common pitfalls of the C programming language.

This article compares a simple C and Go program that adds the numbers from one to ten. Because this program uses only small values, the numbers won't grow to be too big, so they only use plain integer variables. Loops like this are very common in programming, so this simple program makes it easy to compare C and Go.

How to do loops in C

The basic loop in C is the for loop, which allows you to iterate through a set of values. The basic syntax of the for loop is:

for (start condition ; end condition ; action after each iteration) { things to do inside the loop ; }

You can write a for loop that prints the numbers from one to ten by setting the starting condition to count = 1 and the ending condition to count <= 10. That starts the loop with the count variable equal to one. The ending condition means the loop continues as long as the count variable is less than or equal to ten.

After each iteration, you use count = count + 1 to increment the value of the count variable by one. Inside the loop, you can use printf to print the value of the count variable:

for (count = 1; count <= 10; count = count + 1) {
  printf("%d\n", count);
}

A common convention in C programming is ++, which means "add one to something." If you write count++, that's the same as count = count + 1. Most C programmers would use this to write the for loop using count++ for the action after each iteration, like this:

for (count = 1; count <= 10; count++) {
  printf("%d\n", count);
}

Here's a sample program that adds the numbers from one to ten, then prints the result. Use the for loop to iterate through the numbers, but instead of printing the number, add the numbers to the sum variable:

#include 

int main() {
  int sum;
  int count;
  puts("adding 1 to 10 ..");
  sum = 0;

  for (count = 1; count <= 10; count++) {
    sum = sum + count;
  }

This program uses two different C functions to print results to the user. The puts function prints a string that's inside quotes. If you need to print plain text, puts is a good way to do it.

The printf function prints formatted output using special characters in a format string. The printf function can print lots of different kinds of values. The keyword %d prints a decimal (or integer) value.

If you compile and run this program, you see this output:

adding 1 to 10 ..
The sum is 55

How to do loops in Go

Go provides for loops that are very similar to C for loops. The for loop from the C program can be directly translated to a Go for loop with a similar representation:

for count = 1; count <= 10; count++ {
  fmt.Printf("%d\n", count)
}

With this loop, you can write a direct transition to Go of the sample program:

package main
import "fmt"

func main() {
  var sum, count int
  fmt.Println("adding 1 to 10 ..")

  for count = 1; count <= 10; count++ {
    sum = sum + count
  }
  fmt.Printf("The sum is %d\n", sum)
}

While the above is certainly a valid and correct Go, it's not the most idiomatic Go. To be idiomatic is to use expressions that are natural to a native speaker. A goal of any language is effective communication, this includes programming languages. When transitioning between programming languages, it is also important to recognize that what is typical in one programming language may not be exactly so in another, despite any outward similarities.

To update the above program using the more idiomatic Go, you can make a couple of small modifications:

1. Use the += add-to-self operator to write sum = sum + count more succinctly as sum += count. C can use this style, as well.

2. Use the assign-and-infer-type operator to say count := 1 rather than var count int followed by count = 1. The := syntax both defines and initializes the count variable.

3. Move the declaration of count into the for loop header itself. This reduces a bit of cognitive overhead, and increases readability by reducing the number of variables the programmer must mentally account for at any time. This change also increases safety by declaring variables as close as possible to their use and in the smallest scope possible. This reduces the likelihood of accidental manipulation as the code evolves.

The combination of the changes described above results in:

package main
import "fmt"

func main() {
  fmt.Println("adding 1 to 10 ..")
  var sum int
  for count := 1; count <= 10; count++ {
    sum += count
  }

  fmt.Printf("The sum is %d\n", sum)
}

You can experiment with this sample program in the Go playground with this link to go.dev.

C and Go are similar, but different

By writing the same program in two programming languages, you can see that C and Go are similar, but different. Here are a few important tips to keep in mind when transitioning from C to Go:

• In C, every programming instruction must end with a semicolon. This tells the compiler where one statement ends and the next one begins. In Go, semicolons are valid but almost always inferred.

• While most modern C compilers initialize variables to a zero value for you, the C specification says that variables get whatever value was in memory at the time. Go values are always initialized to their zero value. This helps make Go a more memory safe language. This distinction becomes even more interesting with pointers.

• Note the use of the Go package specifier on imported identifiers. For example, fmt for functions that implement formatted input and output, similar to C's printf and scanf from stdio.h. The fmt package is documented in pkg.go.dev/fmt.

• In Go, the main function always returns with an exit code of 0. If you wish to return some other value, you must call os.Exit(n) where n is typically 1 to indicate an error. This can be called from anywhere, not just main, to terminate the program. You can do the same in C using the exit(n) function, defined in stdlib.h.

Explore the basic language constructs of Tcl/Tk, which include user input, output, variables, conditional evaluation, simple functions, and basic event driven programming.

My path to writing this article started with a desire to make advanced use of Expect which is based on Tcl. Those efforts resulted in these two articles: Learn Tcl by writing a simple game and Learn Expect by writing a simple game.

I do a bit of Ansible automation and, over time have collected a number of local scripts. Some of them I use often enough that it becomes annoying to go through the cycle of:

1. Open terminal
2. Use cd to get to the right place
3. Type a long command with options to start the desired automation

I use macOS on a daily basis. What I really wanted was a menu item or an icon to bring up a simple UI to accept parameters and run the thing I wanted to do, like in KDE on Linux.

The classic Tcl books include documentation on the popular Tk extensions. Since I was already deep into researching this topic, I gave programming it (that is wish) a try. 

I've never been a GUI or front-end developer, but I found the Tcl/Tk methods of script writing fairly straight forward. I was pleased to revisit such a venerable stalwart of UNIX history, something still available and useful on modern platforms.

Install Tcl/Tk

On a Linux system, you can use this:

$ sudo dnf install tcl
$ which wish
/bin/wish

On macOS, use Homebrew to install the latest Tcl/Tk:

$ brew install tcl-tk
$ which wish
/usr/local/bin/wish

Programming concepts

Most game-writing articles cover the typical programming language constructs such as loops, conditionals, variables, functions and procedures, and so on.

In this article, I introduce event-driven programming. With event-driven programming, your executable enters into a special built-in loop as it waits for something specific to happen. When the specification is reached, the code is triggered to produce a certain outcome.

These events can consist of things like keyboard input, mouse movement, button clicks, timing triggers, or nearly anything your computer hardware can recognize (perhaps even from special-purpose devices). The code in your program sets the stage from what it presents to the end user, what kinds of inputs to listen for, how to behave when these inputs are received, and then invokes the event loop waiting for input.

The concept for this article is not far off from my other Tcl articles. The big difference here is the replacement of looping constructs with GUI setup and an event loop used to process the user input. The other differences are the various aspects of GUI development needed to make a workable user interface. With Tk GUI development, you need to look at two fundamental constructs called widgets and geometry managers.

Widgets are UI elements that make up the visual elements you see and interact with. These include buttons, text areas, labels, and entry fields. Widgets also offer several flavors of option selections like menus, check boxes, radio buttons, and so on. Finally, widgets include other visual elements like borders and line separators.

Geometry managers play a critical role in laying out where your widgets sit in the displayed window. There are a few different kinds of geometry managers you can use. In this article, I mainly use grid geometry to lay widgets out in neat rows. I explain some of the geometry manager differences at the end of this article.

Guess the number using wish

This example game code is different from the examples in my other articles. I've broken it up into chunks to facilitate the explanation.

Start by creating the basic executable script numgame.wish:

$ touch numgame.wish
$ chmod 755 numgame.wish

Open the file in your favorite text editor. Enter the first section of the code:

#!/usr/bin/env wish
set LOW 1
set HIGH 100
set STATUS ""
set GUESS ""
set num [expr round(rand()*100)]

The first line defines that the script is executable with wish. Then, several global variables are created. I've decided to use all upper-case variables for globals bound to widgets that watch these values (LOW, HIGH and so on).

The num global is the variable set to the random value you want the game player to guess. This uses Tcl's command execution to derive the value saved to the variable:

proc Validate {var} {
    if { [string is integer $var] } {
        return 1
    }
    return 0
}

This is a special function to validate data entered by the user. It accepts integer numbers and rejects everything else:

proc check_guess {guess num} {
    global STATUS LOW HIGH GUESS

    if { $guess < $LOW } {
        set STATUS "What?"
    } elseif { $guess > $HIGH } {
        set STATUS "Huh?"
    } elseif { $guess < $num } {
        set STATUS "Too low!"
        set LOW $guess
    } elseif { $guess > $num } {
        set STATUS "Too high!"
        set HIGH $guess
    } else {
        set LOW $guess
        set HIGH $guess
        set STATUS "That's Right!"
        destroy .guess .entry
        bind all  {.quit invoke}
    }

    set GUESS ""
}

This is the main loop of the value guessing logic. The global statement allows you to modify the global variables created at the beginning of the file (more on this topic later). The conditional looks for input that is out of bounds of 1 through 100 and also outside of values the user has already guessed. Valid guesses are compared against the random value. The LOW and HIGH guesses are tracked as global variables reported in the UI. At each stage, the global STATUS variable is updated. This status message is automatically reported in the UI.

In the case of a correct guess, the destroy statement removes the "Guess" button and the entry widget, and re-binds the Return (or Enter) key to invoke the Quit button.

The last statement set GUESS "" is used to clear the entry widget for the next guess:

label .inst -text "Enter a number between: "
label .low -textvariable LOW
label .dash -text "-"
label .high -textvariable HIGH
label .status -text "Status:"
label .result -textvariable STATUS
button .guess -text "Guess" -command { check_guess $GUESS $num }
entry .entry -width 3 -relief sunken -bd 2 -textvariable GUESS -validate all \
    -validatecommand { Validate %P }
focus .entry
button .quit -text "Quit" -command { exit }
bind all  {.guess invoke}

This is the section where the user interface is set up.  The first six label statements create various bits of text that display on your UI. The option -textvariable watches the given variable and updates the label's value automatically. This displays the bindings to global variables LOW, HIGH, and STATUS.

The button lines set up the Guess and Quit buttons, with the -command option specifying what to do when the button is pressed. The Guess button invokes the check_guess procedure logic above to check the users entered value.

The entry widget gets more interesting. It sets up a three-character wide input field, and binds its input to GUESS global. It also configures validation with the -validatecommand option. This prevents the entry widget from accepting anything other than numbers.

The focus command is a UI polish that starts the program with the entry widget active for input. Without this, you need to click into the entry widget before you can type.

The bind command is an additional UI polish that automatically clicks the Guess button when the Return key is pressed. If you remember from above in check_guess, guessing the correct value re-binds Return to the "Quit" button.

Finally, this section defines the GUI layout:

grid .inst
grid .low .dash .high
grid .status .result
grid .guess .entry
grid .quit

The grid geometry manager is called in a series of steps to incrementally build up the desired user experience. It essentially sets up five rows of widgets. The first three are labels displaying various values, the fourth is the Guess button and entry widget, then finally, the Quit button.

At this point, the program is initialized and the wish shell enters into the event loop. It waits for the user to enter integer values and press buttons. It updates labels based on changes it finds in watched global variables.

Notice that the input cursor starts in the entry field and that pressing Return invokes the appropriate and available button.

This was a simple and basic example. Tcl/Tk has a number of options that can make the spacing, fonts, colors, and other UI aspects much more pleasing than the simple UI demonstrated in this article.

When you launch the application, you may notice that the widgets aren't very fancy or modern. That is because I'm using the original classic widget set, reminiscent of the X Windows Motif days. There are default widget extensions, called themed widgets, which can give your application a more modern and polished look and feel.

Play the game!

After saving the file, run it in the terminal:

$ ./numgame.wish

In this case, I can't give console output, so here's an animated GIF to demonstrate how the game is played:

Image by:

(James Farrell, CC BY-SA 4.0)

More about Tcl

Tcl supports the notion of namespaces, so the variables used here need not be global. You can organize your bound widget variables into alternate namespaces. For simple programs like this, it's probably not worth it. For much larger projects, you might want to consider this approach.

The proc check_guess body contains a global line I didn't explain. All variables in Tcl are passed by value, and variables referenced within the body are in a local scope. In this case, I wanted to modify the global variable, not a local scoped version. Tcl has a number of ways of referencing variables and executing code in execution stacks higher in the call chain. In some ways, it makes for complexities (and mistakes) for a simple reference like this. But the call stack manipulation is very powerful and allows for Tcl to implement new forms of conditional and loop constructs that would be cumbersome in other languages.

Finally, in this article, I skipped the topic of geometry managers which are used to take widgets and place them in a specific order. Nothing can be displayed to the screen unless it is managed by some kind of geometry manager. The grid manager is fairly simple. It places widgets in a line, from left to right. I used five grid definitions to create five rows. There are two other geometry managers: place and pack. The pack manager arranges widgets around the edges of the window, and the place manager allows for fixed placement. In addition to these geometry managers, there are special widgets called canvas, text, and panedwindow that can hold and manage other widgets. A full description of all these can be found in the classic Tcl/Tk reference guides, and on the Tk commands documentation page.

Keep learning programming

Tcl and Tk provide a straightforward and effective approach to building graphical user interfaces and event-driven applications. This simple guessing game is just the beginning when it comes to what you can accomplish with these tools. By continuing to learn and explore Tcl and Tk, you can unlock a world of possibilities for building powerful, user-friendly applications. Keep experimenting, keep learning, and see where your newfound Tcl and Tk skills can take you.

Even though we strive to live every day like Earth Day here on Opensource.com, today is an especially good day to discover new ways to help the planet. Open source brings forth many possibilities for people from all areas and levels of technical expertise.

There are open source tools anyone can use to explore nature's magic, whether looking up at the night sky or down at the plants in your own backyard. Open source empowers web developers to build sustainability into their practice. Our readers love to rescue old computers with Linux, preventing them from piling up in landfills. Homeowners look to open source solutions for monitoring energy usage or installing EV stations. Opens source brings like-minded folks together to solve the world's biggest problems, like hunger and climate change. 

This Earth Day, take the time to reflect on how to incorporate open source into your sustainability habits. 

I love to teach Python. I start by beginning where the learner begins. My first question is, "How would you like to learn Python?"

They usually answer, "What's Python?"

That's when I give them some examples of websites built with Python they might already be familiar with. I also provide examples of using Python in data science, engineering, web development, and, most recently, artificial intelligence and machine learning.

Most folks are intimidated when you try to introduce computer programming because their first efforts failed or someone told them programming is difficult. I show them a simple print statement that easily demonstrates how much the Python syntax is like the language they speak.

>>> print("Hello World")
Hello World

Unless they are Linux or macOS users, they might need help installing Python on their computer. I guide them through downloading Python from the Python.org website and installing it on their computer. Next, I help them set up a development environment. For many users this is IDLE.

A good Python IDE

For a young student, I introduce Mu, a great development environment for elementary and middle school students. Adults and older students might use VSCodium.

Python REPL

I often introduce new users to the REPL so they can execute their code easily. Then I show them how to write a simple program with a print statement print("Hello World") and save it as a text file with a .py extension. I explain that the .py extension is necessary for Python to recognize the program.

Turtle

Then I introduce them to Python fundamentals, including variables, strings, numbers, and basic operations. I suggest Python libraries like the Turtle, which even adults find fascinating. I start simply in the REPL:

import turtle  
turtle.forward(100)
turtle.right(90)

This example demonstrates how easy it is to write code in Python and how just a few lines can produce a graphic on their display. Then I show how to draw a square:

import turtle
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)

Then I cover control structures like the if statement, elif, for, and while. I demonstrate drawing that same square quickly and easily with a for loop:

import turtle
for x in range(4):
    turtle.forward(100)
    turtle.right(90)

Teaching Python is a gift

When you teach, it's important to begin where the learner is and engage them in their own edification. This approach has them leaning in for more information, ensuring they gain skill and competency.

Your local public library might be a great place to find students who would like to learn Python. Most libraries would be very happy to have you volunteer to help their patrons.

Younger generations prioritize experiences over assets and quality over quantity in many areas of life, and technology has evolved to help fulfill their desires. That's the position of Arun Sundararajan in his book The Sharing Economy: The End of Employment and the Rise of Crowd-Based Capitalism. According to Sundararajan, these young people do not want to be burdened with owning unneeded things.

Notice these demand changes:

• Young people don't want to stay at a high-rise hotel. They would rather rent on peer-to-peer accommodation platforms like Airbnb.
• Fewer young people are interested in full-time work and needless commuting to isolated office cubicles. They would prefer working at an internet-based freelance or gig job, working anywhere they choose.
• Young people are turning away from owning and storing things they use only occasionally. They would rather create sharing communities that offer item access, virtual currency exchange, and flexible on-demand services when needed.

With new technologies becoming available, this new lifestyle is becoming more achievable. It is a future in which peer-to-peer exchange becomes increasingly prevalent, and the crowd replaces the corporation at the center of capitalism. The sharing economy, as Sundrararajan defines it, is similar to Jeremy Rifkin's Collaborative Commons, as described in The Zero Marginal Cost Society: The Internet of Things, the Collaborative Commons, and the Eclipse of Capitalism. However you define it, these are growing communities aligned with the principles of open organizations.

Crowd-based capitalism

Sundararajan calls the sharing economy "crowd-based capitalism" and identifies its five characteristics:

• Primarily market-based: It has potentially higher and broad levels of economic activity.
   
• High-impact capital: It opens new opportunities for assets, skills, time, and money to be used at levels closer to their total capacity. It puts idle assets to work where, in the current system, they are wasted.
   
• Crowd-based, non-hierarchical networks: Capital, assets, and labor come from decentralized crowds of individuals rather than centralized corporate or state sources. They are governed by distributed crowd-based marketplace systems or platforms rather than by centralized third parties. Distributed control ensures that value is prioritized, not just profit gain.
   
• Blurring lines between roles: Distinctions like personal vs. professional and producers vs. consumers are less meaningful. Sharing that used to be personal is becoming semicommercial. One can be a producer and consumer simultaneously, supplying newly discovered excess wealth-producing assets.
   
• A changing work environment: The differences between fully employed and casual labor, independent and dependent employment, and work and leisure are less clear.

These characteristics illustrate why terms like the "collaborative economy," the "gig economy," the "peer economy," the "renting economy," and the "on-demand economy" are part of the sharing economy. The sharing economy has commercial characteristics, but there is also a gift economy that serves both an economic purpose and social and cultural functions. For example, Collab Fund is a fund that invests almost exclusively in the sharing economy. All investors are angel investors that believe in the purpose of the investment.

Sundararajan maintains that the twentieth century was defined by hyperconsumption, whereas the twenty-first century may become the century of collaborative consumption. Hyperconsumption differs from collaborative consumption in four ways:

• Buying individually on credit vs. collaborative joint purchasing, sharing, and trusted community building
• Mass advertising vs. community interaction
• Individual ownership vs. sharing access to assets
• Global and regional syndication vs. local and virtual face-to-face networking

These patterns fit nicely in situations where open organization principles can play a major role. The sharing economy reflects a shift away from faceless, impersonal twentieth-century capitalism and toward exchange that is more connected and more embedded in a community with a purpose. Within the sharing economy, there are social cues to the importance of trust, reputation, and a digital community facilitating service to others. Exchange includes a gift factor that promotes a feeling of reciprocation and connection. These elements lead to a human bond between the two exchange parties.

This cohesion is central to the sharing economy. It embraces exchanging services and value with others even though payback is not clearly defined. Sometimes, the joy of giving and the good feeling of being generous to a stranger are enough.

Expanding the transaction-to-gift spectrum

Sundararajan writes, "Gift exchange tends to be an economy of small groups, of extended families, small villages, close-knit communities, brotherhoods, and, of course, tribes." Today's sharing economy scales behaviors and forms of exchange long familiar in such communities to a broader, loose-knit digital community of semi-anonymous peers. These exchanges are on a continuum between the gift economy and a market-transaction economy, with very few at the ends of the spectrum and many more at some point in between. Consider the Couchsurfing platform. You join this platform by setting up an account; to do that, you must verify your identity. Once becoming a member, you can sleep on other members' couches, and they can sleep on yours. There is no financial exchange. No one monitors whether you offer your couch or use other members' couches more.

Users say they are attracted to this platform primarily by the opportunity to meet people or make new friends—a representation of the open organization principle of community or network building. Finding a place to stay is of secondary value. Hospitality and a desire to connect with other human beings drive the Couchsurfing platform. Sometimes a Couchsurfing member contacts another member in a strange city just to socialize without a stay, simply to interact with a local person within an unfamiliar community. This human interaction results in positive experiences, resulting in favorable reviews, which could result in finding accommodations more easily in the future.

Expanding the sharing business model in the future

What social factors promote sharing? One is the continuing growth of the global urban population. People are physically becoming closer and, therefore, can more easily share underused assets. There will be continued growth of megacities with a population of over 10 million worldwide. Forecasts suggest that all future population growth will be in urban areas, particularly these megacities. Consider: People in cities share public parks, transportation, and apartment buildings without a thought. No one would consider purchasing and individually owning any of these public assets. The more densely populated an area is, the more sharing will happen naturally. Furthermore, with less space, people will not want to fill their space with things unless those things are in great need and regular use. These factors lead to more peer-to-peer sharing and less individual ownership.

In the book Peers, Inc, Robin Chase gives many examples of how the supply of many goods and services that used to come from corporations and the government may come from peers in the community. Chase writes that emerging practices such as the sharing economy, crowdsourcing, collaborative production, and collaborative consumption create more peer-to-peer, peer-to-business, and peer-to-government projects, and more small-business-to-big-business interaction. With this growth, open organization principles will become increasingly important.

All the above will improve the Human Development Index, which measures factors like global education and health. Worldwide, people will be able to buy goods and services they could never have afforded before. Prices will become lower than the market requires. People will have more disposable income. Platforms will be able to match product features to exactly what users need and want, so they needn't buy a lot of add-on features. Skills and tasks are already being performed more efficiently through platforms, so you can buy the specific task instead of paying randomly assigned hourly rates.

Platforms' importance in the growth of sharing projects

Durable goods for short-term use have mainly been provided by rental or leasing equipment companies. The problem for rental companies is they may not want to purchase something if there is not strong enough continual rental demand. Durable goods that last a long time are likely to have idling capacity. Anyone who owns them can get into the durable goods rental business if the transaction and marketing costs are low enough. Consider camping equipment, like tents, camping stoves, or sleeping bags. These could be rented out when not needed if the effort required were easy enough.

This is where platforms come in. A person could buy more than enough camping equipment for the family with the idea of renting it out when not used themselves, using a particular platform. This strategy could be financially rewarding and, more importantly, could build a friendly camping community. This could also apply to skills: A person's low utilization day can support another person's overly high utilization day. One person keeps busy while pressure is taken off of an overworked person.

Regulation and consumer protection

Peer-to-peer platforms create new and different regulatory challenges. Standardized regulations may make sense on a large scale but are not suited to small person-to-person arrangements. The question is, can trust and consumer protection be established and enforced without putting too much restriction on small, vulnerable microentrepreneurs? One approach is to form a guild within the community that can act as arbitrators of disputes. These guilds have experts and experienced members who can fairly address most issues. They can act as third-party mediators. Peers.org is a collective action platform that can start petitions and collective actions when there is improper behavior in private or public institutions. A platform like this could monitor and respond to digital, virtual, and physical issues within a given community.

Left alone, market practices can produce inefficient, inequitable, or insufficient outcomes, which economists call market failure. This can happen when there is an imbalance in knowledge between provider and user. Sundararajan offers three suggestions to mitigate this problem:

Peer regulation

Recommendations, referrals, suggestions, and product reviews among third-party peers are compelling. They can build or destroy a business's reputation and social capital. A sharing community sets standards and works collectively to ensure those standards are maintained. With today's technology, a platform can develop the appropriate community and regulatory framework. eBay has its Power Sellers, for example, and BlaBlaCar offers an explicit certification of trust based on driving reputation. In microfinancing, your reputation can substitute for credit history. Yelp started as a restaurant rating platform but now rates many things. Third-party certification can also help maintain acceptable standards. Furthermore, to build a trusted business relationship early, paying more than the market requires and keeping early transactions small enough to avoid heavy losses might be wise.

Self-regulation

Platforms want to reduce market failures that would create a bad reputation and deter people from using their services. In response, they create platform volunteers that educate and inspect the activities of people using it. Profiles on platforms like Facebook and LinkedIn can also form a digitally verified ID. Some websites also offer criminal background checks and driving histories. These could be voluntarily provided if there is a concern.

Furthermore, self-regulation could happen through building coalitions (self-regulatory organizations or SROs). Coalitions can be like self-governing bodies or guilds. They define standards, monitor them, and govern specific industries or professions, not just individuals. They rate each agent and determine trustworthiness. Within the sharing economy, Sundararajan believes these guilds must:

• Establish credibility early
• Demonstrate strong enforcement
• Be perceived as independent
• Take advantage of participants' reputational concerns and social capital

Community trust can be built to form long-term relationships. More than one transaction will be required for a lifetime career. The successful completion of one transaction leads to future transactions. The community must have communication networks that monitor successful transactions. Lastly, consideration must be given to those that don't use the service, like an Airbnb host's neighbors. It may be wise to join local co-op associations, condominium boards, or homeowner associations.

Regulation through data

Technology can provide governance, from simple devices like taxi-metering equipment to advanced algorithms. Many websites mine data from their users, which must be carefully used with both the suppliers' and users' permission. If they grant permission, communities can monitor much information about satisfaction. In addition, digital security systems can detect and block fraudulent activities swiftly. Even cameras that detect repeated lack of smiles can identify signals to point out concerns.

Sundararajan does not argue that government safety laws and regulations are not required. However, community-based and internal regulation is more powerful in many countries than existing laws. Governments will have to play a supporting role in making this business model more successful: Legal standards would be helpful, and industrial guidelines and inspections could make these services more reliable.

The time to start is now

This article, and earlier articles in the series, illustrate how the sharing economy can do a better job of putting to greater use what is now available, including our skills. The sharing economy is here to stay. Anyone able to develop platforms should consider sharing economy ideas very seriously.

Some of the most familiar examples of the online sharing economy started small. Consider Airbnb, which started from three airbeds and became AirBed and Breakfast in 2008. As of 2016, 70 million guests have stayed in a stranger's home via Airbnb. The internet-based platform connects people who have a resource not used to capacity—excess space—with others who can use it and provides a means for them to establish trust. It's a perfect example of the sharing business model.

In an earlier article, I introduced the principles behind businesses based on social connection, drawing from the book The Sharing Economy: The End of Employment and the Rise of Crowd-Based Capitalism by Arun Sundararajan. I will discuss several examples of the sharing business model in this article.

A market for connections

According to Sundararajan, the economic fundamentals of crowd-based capitalism are superior to the current profit-based business model because the raw materials for this economy—space, time, items, and skills—are in excess. Because they already exist, they don't create additional costs to offer them. You could consider it a form of improved resource use conservation, environmental protection or the sustainability economy.

Human relations are a significant value component of the sharing economy. For example, some ride-sharing operators want passengers to sit in the front seat to generate conversation and interaction. The service is about social connection as well as ride-sharing. Since many drivers work part-time as a small side job, the interaction may be just as valuable to them as the fee received.

Here are two weaknesses of traditional taxi services:

• Poor hospitality
• Poor occupancy (utilization) rates because of the business structure (vehicle ownership by driver or company)

Crowd-based, public-private ownership using digital technology apps can tap into decentralized excess capacity that friendly people have rather than single company-owned centralized systems. Hospitality improves, and there is no additional up-front investment. There are sites to outsource the buying and delivery of your groceries, an app to help valet parking services locate cars and parking spaces with GPS, a mail pickup service, laundry pickup, dog walking, and much more.

How platforms build trust

eBay started in 1995 by moving the neighborhood garage sale online and offering isolated booksellers and thrift shop owners a way to expand their market reach outside their local community. The eBay system has many safeguards that protect both buyers and sellers through the transaction processes, so eBay maintains trading partner trust even with great geographic distance between buyers and sellers. For services offered in the sharing economy, location is more important. Peer-to-peer service markets may be more suitable for densely populated urban areas.

Building provider and user trust is an essential factor in making the sharing economy successful. To determine whether or not to place trust in a provider, consumers must consider the vetting process of each platform. What is the quality of their rating system? Some organizations use Facebook friendships as testimonials to confirm trustworthy people. Some platforms completely control the payment system, so payment is assured, but others don't.

Frederic Mazzella, a cofounder of BlaBlaCar, believes trust is central to his company's business and is passionate about its importance. BlaBlaCar's corporate headquarters has a life-sized cardboard cutout of Trust Man, a cape-wearing superhero with a "T" emblazoned on his jumpsuit. Mazzella's conception of trust is based on what he calls the D.R.E.A.M.S. framework: Declared, Rated, Engaged, Activity-based, Moderated, and Social. The company is constantly working on deepening its understanding of trusted exchange.

Collaboration and community building

The organization OuiShare coordinates activities to foster collaboration. In June 2021, they gathered more than 600 people over the three days of OuiShare Fest, which included conferences, workshops, performances, and shows. With this event, OuiShare aspired to create social connections, projects, and collaborations by bringing together people from different backgrounds. Participants explored what they have an excess of and what might be needed and shared. The group started in France and now exists in 20 countries in Europe, where it provides a shared platform for experimentation that gives connectors and members access to a commons of knowledge, tools, and an international network of people from whom to learn and draw inspiration. You could call it transparency of the underused.

Service platforms offer the spare time of people with knowledge, skills, or talent. For example, some platforms provide teachers with specific knowledge and skills in exchange for other knowledge or excess material goods, but not money.  

This article is part of a series on the sharing economy. In the first article, I explained the sharing business model and its value. In this article, I gave many examples of platforms in operation now. In a future article, I will explore how the sharing business model will evolve.

Drupal 10 was released in December 2022. If you're a current Drupal 9 user, you may be strategizing your website's Drupal 9 to 10 migration. Luckily, the Drupal 9 to 10 migration is being heralded as the easiest upgrade in Drupal's history. That's because Drupal 10 is backward-compatible with Drupal 9 and is not a major overhaul of the core system. But the planning and development process still requires time and attention to ensure the migration goes smoothly.

This article takes a deep dive into the Drupal migration process and how your organization's marketing team can provide support along the way.

Fast facts about the Drupal 9 to 10 migration

Brush up on your Drupal release history with these fast facts:

• Drupal 9 was released in June 2020. At the time of its release, Drupal 9 offered an easier upgrade than ever because it built upon features released for Drupal 8.
• Support for Drupal 9 ends in November 2023. There won't be many new security releases after this time, and no new functionality will be added.
• Drupal 10 was released on December 14, 2022. New features will only be added to Drupal 10 from now on, so if you're looking to use Drupal for the first time, it's recommended to start with Drupal 10.

What's new in Drupal 10?

As mentioned, Drupal 10 builds on innovations released as part of Drupal 9. You won't encounter an entirely new structure and system to get used to when switching to Drupal 10.

That being said, Drupal 10 offers the following updated features to improve the user experience:

• A new default administrative theme and frontend theme: The default Claro administration theme and the Olivero frontend theme offer an accessible, user-friendly, modern experience for website administrators and visitors alike.
• Updates to the CKEditor embedded text editor from V4 to V5: This change facilitates a more modern editing experience and more intuitive authoring.
• Upgrade from the PHP framework Symfony 4 to Symfony 6: Symfony 6 and switching to PHP 8.1 as the minimum version results in a more secure, performant PHP framework.
• Modernization of JavaScript: Drupal 10 switches out the large JQuery library with smaller, better-performing solutions.

Specific technologies aside, Drupal 10 focuses on accessibility, modernization, and user-friendliness for website visitors and editors alike.

Steps to upgrade from Drupal 9 to 10

If you upgraded your site from Drupal 7 to 9 in the past, you know that migration required transferring all of your data to a new Drupal 9 website. The Drupal 9 to 10 migration is similar to the upgrade from Drupal 8 to 9, so it won't be such a significant undertaking.

However, you can still take a few measures to set your website up for success. Follow these steps to prepare your Drupal 9 site for the migration:

• Drupal version: Upgrade to at least Drupal 9.4.4 or later. Core updates made before 9.4 have been eliminated, so you must be on at least Drupal 9.4.4 to use the data upgrade path from CKEditor 4 to CKEditor 5.
• Rector: Run Drupal Rector on custom modules and themes. Drupal Rector scans code to look for deprecated functions and helps guide developers to upgrade them.
• CKEditor: Upgrade to CKEditor 5. CKEditor 4 reaches its end-of-life at the end of 2023. Check out Drupal's step-by-step instructions for upgrading to CKEditor 5 to stay up to date.
• PHP: Check your version of PHP. Drupal 10 requires PHP 8.1 or higher, so you may need to update your PHP code. Log into your website's hosting account and check the settings in your control panel to verify which version of PHP you're using.
• Modules and themes: Check your modules and themes. Not all modules and themes from Drupal 9 will be compatible with Drupal 10. If your site uses a module or theme that was removed from Drupal core, download the contributed project version before migrating to Drupal 10.
• Test: Update to Drupal 10 and test your site. Run automated code tests using tools like Drupal Rector or PHPStan. Also, conduct manual testing to ensure that everything is working as expected. Check your forms, links, page navigation, and other site elements to note any user-experience issues.

Hassle-free upgrade

Ideally, upgrading your website from Drupal 9 to 10 shouldn't be a hassle. You can make the already simple process even easier with the tips I've provided. You can take these steps yourself, let your web developer handle it, or work with an external Drupal developer.

This article was adapted from a previous article by Jim Birch, Drupal engineering manager at Kanopi Studios.

The sharing economy is a new industry built around sharing resources  instead of buying things new from a factory. If an asset is not being used to capacity by the owner, there may be others who can use it so the asset is utilized to its full potential. The Sharing Economy: The End of Employment and the Rise of Crowd-Based Capitalism, by Arun Sundararajan, gave me many new insights about this business model and how it relates to many open organization activities.

The business model of the sharing economy

The sharing economy is all about the transparency of people's unused or underused assets. Through various computer platforms, communities form among parties that provide and parties that use these excess assets. These communities can greatly expand inclusivity, for example by extending resources to poorer communities and bringing more people into the global economy. Anyone can become part of the larger economy by providing excess resources, including underused time, tools, and capacity. The sharing economy establishes new opportunities for both supply and demand opportunities. Through newly developed platforms, people can collaborate around goods and services in a way that has not been possible before.

Put simply, all five open organization principles are represented in this business model:

• Transparency
• Inclusivity
• Adaptability
• Collaboration
• Community

New social values as a sharing business model

According to Sundararajan, a professor at New York University's Stern School of business, social values in the sharing economy are, at best, weak in commercial economies.

For example, services like home cleaning, plumbing, painting, or electrical work can be offered or hired through a labor marketplace like Handy, TaskRabbit, or Thumbtack. Participants can validate their identities by sharing data from a valid Facebook or LinkedIn account. While all of these examples involve sharing—in this case, sharing time—none of these services are offered for free. You get paid by the person you serve, or you pay the provider who shares what they have with you. Providing services for profit is not the principal goal, however. While these activities can be profitable for both supplier and receiver, the opportunity to make new social connections can be fun and rewarding.

The sharing economy is not new, according to Sundararajan. Before the Industrial Revolution, much economic exchange was peer-to-peer, embedded in communities, and intertwined in various ways with social relations. About 50% of the population at the turn of the 20th century was self-employed. By 1960, that number was around 15%, as large corporations increasingly dominated the economy. Now, digital technologies are bringing sharing behavior, self-employment, and community-based exchange back to life.

Technology is building new forms of economic communities far beyond family, friends, neighborhoods, cities, or even nations. The sociologist Juliet Schor calls this "stranger sharing," including building trusting relationships with people you don't directly know. Sundararajan calls this "crowd-based capitalism," and it could radically transform the meaning of a job, reshaping employment regulations and social safety nets.

Exposing underused assets

There are a lot of slack resources in most economies. Many assets sit idle most of the time—for instance, the average car is driven just an hour a day. Workers in a company have time and skills that go unused. Sundararajan contends that if you connect people with unused assets (an item, space, time, or skills) to people willing to pay to use them, you reduce waste and end up with a more efficient system. Technology is already bringing those parties together and building supplier/user communities, as in food-sharing and car-sharing cooperatives, barter exchange systems, bike-sharing initiatives, cohousing programs, and coworking policies.

The Sharing Economy explains that the conditions for collaborative consumption occur when there is a critical mass of idle capacity. There are three key factors:

• Untapped value of unused or underused assets
• Belief in serving the common good with what is available
• A system that allows strangers to meet and trust each other

People's spare time, items, skills, and space are being detected, dramatized, and made more transparent through digital networks. For example, Alex Stephany is the CEO of JustPark, a peer-to-peer marketplace that matches people who have empty parking spaces with those looking for a place to park. In his book The Business of Sharing: Making It in the New Sharing Economy, he defines the sharing economy as "the value in taking underutilized assets and making them accessible online to a community, leading to a reduced need for ownership of those assets." Stephany has proposed five characteristics of a sharing economy:

• It creates economic value.
• Its raw materials are currently available underutilized assets.
• It operates through online accessibility.
• It builds a community that develops trusting relationships, social interaction, and value sharing.
• It reduces the need for sole ownership of an asset.

The technology for these characteristics is supported by free software (or app development), distributed computing, and population-scale digital networks. These huge networks must be developed to support trusted, highly distributed communities.

Purpose over profits

Much of the world is experiencing a new economic model that includes older economic models once marginalized under capitalism. The capital cost of effective economic action in the industrial economy shunted sharing to the periphery. With the technology mentioned above more available, the sharing economy will become more mainstream.

Furthermore, social characteristics, social cues, and differing motivations in the sharing economy are replacing profit-only goals. Characteristics such as generating information and motivating action will change how people think about basic economic activities. There will be a move toward purpose-driven communities within the profit-driven sectors of the sharing economy. Networking in this economy will be more peer-to-peer and have different production systems, governance systems, and ownership arrangements. Powered by TCP/IP protocol, a truly decentralized system will replace centralized distribution and govern supply chains and flows.

In his book Remix: Making Art and Commerce Thrive in the Hybrid Economy, Lawrence Lessig describes thin sharing economies as "economies where the motivation is primarily me-regarding or meant to serve the individual." By contrast, thick sharing economies are "economies where the motivations are at least ambiguous between me and thee motivation," or, in other words, motivation is oriented in some part toward the self and in some part toward others.

Commercial economies build value with money at their core. Sharing economies build value while ignoring money. Between these two economies, there is an increasingly important third economy that builds upon both the sharing and commercial economies and adds value to each. This hybrid economy may start with a commercial entity, for example, a business-model platform that leverages value from sharing. Or it could begin with a social connection platform that builds a commercial entity to support its sharing aims better.

Building a trusting community

In a sharing economy, trusting others will be transformed from a scarce resource to an abundant one through available communication technology. The sharing economy allows people to trust strangers at levels that were not previously possible through multiple systems generating reliable digital cues—a digital trust infrastructure. According to Sundararajan, the emergence of today's sharing economy is primarily due to digital enablers that have gradually gained strength and acceptance, mainly through mass-market smartphones, ubiquitous wireless broadband, along with an ever-improving trust system. This includes digitized real-world social networks built on decentralized marketplace protocols, identification systems, recommendation systems, testimonials, and peer-to-peer referrals.

To establish trust in an online setting, Sundarajan proposes three factors:

• Verify identity: Consider getting references and third-party confirmation.
• Confirm intentions: Does this person have other competing interests within this agreement? Determine what they hope to achieve for themselves, including the joy of helping others.
• Determine capacity: Can this person really do what they say they can? Analyze the person’s ability to deliver on their side of the arrangement.

In addition to the above, Sundararajan suggests asking these questions when assessing semi-anonymous, internet-based peer-to-peer settings:

• What is the status of prior interactions? Could you try a small, low-risk test and determine trustworthiness?
• What is the experience of others? How have others been treated?
• What are the platform brand and policy conditions? Through the platform, are there any validation procedures?
• What is the overall digitized reputation in the community? Take a look at any analytics available, including reviews and testimonials.
• Are external validations or references available? Are there any independent evaluations offered?

Familiarity is a cumulative process that develops over time. Each positive experience can increase trust, particularly when announced on a reputation system. For instance, eBay has created a Power Sellers classification to identify high-trust individuals. In this system, the platform does the vetting, so the provider can build trust just by being accepted. Other means of establishing identity and trustworthiness could include having a mobile number tied to a monthly subscription plan or holding a driver's license or credit card in front of a webcam for a service like Jumio to validate your identity.

Currently, a good reputation on one platform may not be transferred to another platform. The platform Traity is building a general-purpose reputation program. It also verifies your government ID and links to your digital social capital on Facebook or LinkedIn. This can help make people more comfortable with others they've never met. These identity measures will further enable the introduction and application of the open organization principle of community building.

In future articles on this topic, I will present many sharing platforms that are available today and discuss what Sundararajan believes the future holds for the sharing economy.

Open source tools have been instrumental in advancing technology and making it more accessible to everyone. Data analysis is no exception. As data becomes more abundant and complex, data scientists always look for ways to simplify their workflow and create interactive and engaging visualizations. PyGWalker is designed to solve such problems.

PyGWalker (Python binding of Graphic Walker) connects a working environment of Python Jupyter Notebook to Graphic Walker to create an open source data visualization tool. You can turn your Pandas dataframe into a beautifully crafted data visualization with simple drag-and-drop operations.

Image by:

(Bill Wang, CC BY-SA 4.0)

Get started with PyGWalker

Use pip to install PyGWalker:

$ python3 -m pip install pygwalker

Import pygwalker and pandas to use it in a project:

import pandas as pd
import pygwalker as pyg

Load data into a Pandas datagram and call PyGWalker:

df = pd.read\_csv('./bike\_sharing\_dc.csv', parse\_dates=\['date'\])
gwalker = pyg.walk(df)

You now have a graphical UI to explore and visualize your Pandas dataframe!

Explore data with Graphic Walker

One of the key features of Graphic Walker is the ability to change mark types to create different kinds of charts. For example, create a line chart by changing the mark type to a line.

Image by:

(Bill Wang, CC BY-SA 4.0)

You can also compare different measures by creating a concat view, which adds more than one measure into rows and columns.

Image by:

(Bill Wang, CC BY-SA 4.0)

Put dimensions into rows or columns to create a facet view of several subviews divided by the value in a dimension.

Image by:

(Bill Wang, CC BY-SA 4.0)

In the Data tab, you can view the data frame in a table and configure the analytic and semantic types.

Image by:

(Bill Wang, CC BY-SA 4.0)

Data exploration with PyGWalker

You can turn your Pandas data into graphical and highly-customizable charts with PyGWalker. You can also use PyGWalker as a powerful tool for exploring data to uncover underlying patterns, trends, and insights.

Data exploration options are available in the Exploration Mode option (in the toolbar). They can be set to either Point Mode or Brush Mode.

• Point Mode: Explore data by pointing your mouse cursor at a specific segment of the data.
• Brush Mode: Explore data by drawing a selection box around a range of data and then drag it to see generated insights.

Try this to see your data

You can try PyGWalker on these cloud demos: Google Colab, Binder, or Graphic Walker Online Demo.

PyGWalker is an excellent tool for simplifying data analysis and visualization workflows, particularly for those who want a visual interface for Pandas. With PyGWalker and Graphic Walker, data scientists can easily create stunning visualizations with simple drag-and-drop operations in Jupyter Notebook. Check out the PyGWalker Git repository for the source code.

For data scientists who seek an open source solution to automated data exploration and advanced augmented analytics, the project also works on RATH, an open source auto-EDA, AI-empowered data exploration and visualization tool. You can also check out the RATH Git repository for the source code and an active community.

Open source projects that create a wrapper around an API are becoming increasingly popular. These projects make it easier for developers to interact with APIs and use them in their applications. The openshift-python-wrapper project is a wrapper around openshift-restclient-python. What began as an internal package to help our team work with the OpenShift API became an open source project (Apache License 2.0).

This article discusses what an API wrapper is, why it's useful, and some examples from the wrapper.

Why use an API wrapper?

An API wrapper is a layer of code that sits between an application and an API. It simplifies the API access process by abstracting away some of the complexities involved in making requests and parsing responses. A wrapper can also provide additional functionality beyond what the API itself offers, such as caching or error handling.

Using an API wrapper makes the code more modular and easier to maintain. Instead of writing custom code for every API, you can use a wrapper that provides a consistent interface for interacting with APIs. It saves time, avoids code duplications, and reduces the chance of errors.

Another benefit of using an API wrapper is that it can shield your code from changes to the API. If an API changes its interface, you can update the wrapper code without modifying your application code. This can reduce the work required to maintain your application over time.

Install

The application is on PyPi, so install openshift-python-wrapper using the pip command:

$ python3 -m pip install openshift-python-wrapper

Python wrapper

The OpenShift REST API provides programmatic access to many of the features of the OpenShift platform. The wrapper offers a simple and intuitive interface for interacting with the API using the openshift-restclient-python library. It standardizes how to work with cluster resources and offers unified resource CRUD (Create, Read, Update, and Delete) flows. It also provides additional capabilities, such as resource-specific functionality that otherwise needs to be implemented by users. The wrapper makes code easier to read and maintain over time.

One example of simplified usage is interacting with a container. Running a command inside a container requires using Kubernetes stream, handling errors, and more. The wrapper handles it all and provides simple and intuitive functionality.

>>> from ocp_resources.pod import Pod
>>> from ocp_utilities.infra import get_client
>>> client = get_client()

ocp_utilities.infra INFO Trying to get
client via new_client_from_config

>>> pod = Pod(client=client, name="nginx-deployment-7fb96c846b-b48mv", namespace="default")
>>> pod.execute("ls")

ocp_resources Pod INFO Execute ls on
nginx-deployment-7fb96c846b-b48mv (ip-10-0-155-108.ec2.internal)

'bin\nboot\ndev\netc\nhome\nlib\nlib64\nmedia\nmnt\nopt\nproc\nroot\nrun\nsbin\nsrv\nsys\ntmp\nusr\nvar\n'

Developers or testers can use this wrapper—our team wrote the code while keeping testing in mind. Using Python capabilities, context managers can provide out-of-the-box resource creation and deletion, and inheritance can be used to extend functionality for specific use cases. Pytest fixtures can utilize the code for setup and teardown, leaving no leftovers. Resources can even be saved for debugging. Resource manifests and logs can be easily collected.

Here's an example of a context manager:

@pytest.fixture(scope="module")
def namespace():
    admin_client = get_client()
    with Namespace(client=admin_client, name="test-ns",) as ns:
        ns.wait_for_status(status=Namespace.Status.ACTIVE, timeout=240)
        yield ns

def test_ns(namespace):
    print(namespace.name)

Generators iterate over resources, as seen below:

>>> from ocp_resources.node import Node
>>> from ocp_utilities.infra import get_client
>>> admin_client = get_client()
# This returns a generator
>>> for node in Node.get(dyn_client=admin_client): 
        print(node.name)

ip-10-0-128-213.ec2.internal

Open source code for open source communities

To paraphrase a popular saying, "If you love your code, set it free." The openshift-python-wrapper project started as utility modules for OpenShift Virtualization. As more and more projects benefitted from the code, we decided to extract those utilities into a separate repository and have it open sourced. To paraphrase another common saying, "If the code does not return to you, it means it was never yours." We like saying that once that happens, it's truly open source.

More contributors and maintainers mean that the code belongs to the community. Everyone is welcome to contribute.