Feeds

Alex Moreno shares his personal experience from DrupalCon Singapore 2024, offering insights on AI-driven Drupal innovations, the upcoming Experience Builder release, and the growing momentum in Asia’s Drupal market. From roundtable discussions to contribution highlights, get an inside look at the key moments shaping Drupal’s future.

This release fixes AI Chat to continue to work after OpenAI drops v1 API support this month, uses the configured AI model also for AI Chat, fixes the debugger to work when two or more versions of Python are loaded into a process, improves OpenAI Assistant, File, and Vector Store resource management, reduces debugger stack space usage, fixes using ${WING:PROJECT_DIR} and other environment variable references in a Python File OS Commands, and fixes several other minor usage issues.

See the change log for details.

Important Note: Users of the AI Chat beta in Wing version 10.0.7.1 and earlier may find many untitled Vector Stores in their OpenAI account, which were left as a side effect of Wing's earlier use of the beta Assistants API. OpenAI may start charging for these or other resources in your OpenAI account at the end of 2024. These resources can be removed by invoking internal-ai-delete-resources(untitled_vector_stores=True) from the Edit > Command by Name menu. This runs in the background, may take several minutes to finish, and will be terminated if Wing is quit before it completes. Use caution if you have other applications that call OpenAI's Assistants API, as this cannot distinguish the Vector Stores created by Wing and other applications. Once resources have been deleted, you will need to restart all instances of Wing before AI Chat will work again. Afterward, you should not see any further accumulation of Vector Stores or other resources in your OpenAI account, other than those that are actively in use. However, please note that Wing's AI Chat is based on API that is still being flagged as 'beta' by OpenAI.

Download Wing 10 Now: Wing Pro | Wing Personal | Wing 101 | Compare Products

What's New in Wing 10

AI Assisted Development

Wing Pro 10 takes advantage of recent advances in the capabilities of generative AI to provide powerful AI assisted development, including AI code suggestion, AI driven code refactoring, description-driven development, and AI chat. You can ask Wing to use AI to (1) implement missing code at the current input position, (2) refactor, enhance, or extend existing code by describing the changes that you want to make, (3) write new code from a description of its functionality and design, or (4) chat in order to work through understanding and making changes to code.

Examples of requests you can make include:

"Add a docstring to this method" "Create unit tests for class SearchEngine" "Add a phone number field to the Person class" "Clean up this code" "Convert this into a Python generator" "Create an RPC server that exposes all the public methods in class BuildingManager" "Change this method to wait asynchronously for data and return the result with a callback" "Rewrite this threaded code to instead run asynchronously"

Yes, really!

Your role changes to one of directing an intelligent assistant capable of completing a wide range of programming tasks in relatively short periods of time. Instead of typing out code by hand every step of the way, you are essentially directing someone else to work through the details of manageable steps in the software development process.

Read More

Support for Python 3.12, 3.13, and ARM64 Linux

Wing 10 adds support for Python 3.12 and 3.13, including (1) faster debugging with PEP 669 low impact monitoring API, (2) PEP 695 parameterized classes, functions and methods, (3) PEP 695 type statements, and (4) PEP 701 style f-strings.

Wing 10 also adds support for running Wing on ARM64 Linux systems.

Poetry Package Management

Wing Pro 10 adds support for Poetry package management in the New Project dialog and the Packages tool in the Tools menu. Poetry is an easy-to-use cross-platform dependency and package manager for Python, similar to pipenv.

Ruff Code Warnings & Reformatting

Wing Pro 10 adds support for Ruff as an external code checker in the Code Warnings tool, accessed from the Tools menu. Ruff can also be used as a code reformatter in the Source > Reformatting menu group. Ruff is an incredibly fast Python code checker that can replace or supplement flake8, pylint, pep8, and mypy.

Try Wing 10 Now!

Wing 10 is a ground-breaking new release in Wingware's Python IDE product line. Find out how Wing 10 can turbocharge your Python development by trying it today.

Downloads: Wing Pro | Wing Personal | Wing 101 | Compare Products

See Upgrading for details on upgrading from Wing 9 and earlier, and Migrating from Older Versions for a list of compatibility notes.

Ruqola 2.4.0 is a feature and bugfix release of the Rocket.chat messenger app.

Some of the new features in this release of Ruqola include:

• Allow to clean up room history when room was not opened for a long time.
• Add restore button in administrator server settings dialog.
• Improve changing password (show validation info).
• Improve register new account (Add reason support).
• Implement mute/unmute user.
• Add color to the text in the account tab.
• Allow to show private installed applications.

Some bug fixing:

• Fix editing message.
• Show permissions in Rocket.Chat Marketplace.
• Fix reconnect server.
• Fix single application on Windows/MacOs
• Fix select created room/discussion/teams
• Fix filter discussion in administrator mode
• Fix message video support
• Fix highlight text in quoted message
• Fix open discussion channel
• Allow to show application market settings

URL: https://download.kde.org/stable/ruqola/
Source: ruqola-2.4.0.tar.xz
SHA256: f532e421ae731dfc2e88b78ab61de01e0e367a31a4fe34497664a66fc737225c
Signed by: E0A3EB202F8E57528E13E72FD7574483BB57B18D Jonathan Riddell jr@jriddell.org
https://jriddell.org/jriddell.pgp

A practical two day course on the object oriented features of Python. Perfect for programmers with some experience of Python looking to use objects and classes and to understand them. An excellent course for data scientists, devops engineers and those self taught with Python looking to move beyond scripting into programming.

• Object Oriented Programming Theory with Python

Course Contents

Fundamentals: Classes and methods

• Computer architecture and programming languages
• Python as a high-level, object-oriented language
• Objects as abstractions, for thinking
• The class statement
• The explicit self
• The initialiser method __init__
• Bound methods
• Attributes and the built-in attribute access functions
• References and assignment (how Python works)
• Mutable objects (and call by object)
• Object copying

Object Oriented Features

• Class attributes
• Class methods
• Properties
• Private attributes
• Single inheritance
• Inheritance to extend and modify the parent
• The use of super
• Cooperative multiple inheritance
• Mixin Classes
• Attribute lookup and the method resolution order
• The type system: isinstance and issubclass

Inside Python Objects

• The instance dictionary
• Slots
• Class dictionaries
• The descriptor protocol

Python Protocols

• Magic methods and Python protocols
• Operator overloading
• The string representation protocol
• The container protocols
• Implementing custom containers
• Inheriting from collections.abc.MutableSequence

Alternative Approaches

• namedtuples
• dataclasses
• type as a class factory

Object oriented theory:

• History of Object Oriented Programming
• The pillars of OOP
• Abstraction
• Inheritance
• Encapsulation
• Polymorphism
• Object oriented design principles
• Design patterns
• The Liskov Substitution Principle
• Composition versus inheritance

Optional advanced section (third day):

1. Advanced OOP Concepts

   • Interfaces and API design
   • Abstract base classes and protocols
   • Type hints and static typing with mypy
   • Class decorators
   • Decoration via inheritance with __init_sublass__
   • Metaclasses
   • Context managers and the with statement
   • Weak references and destructors
   • The descriptor protocol

2. OOP Design Principles

   • SOLID principles
   • Law of Demeter
   • Liskov Substitution Principle
   • Composition vs inheritance
   • Domain Driven Design
   • Test Driven Development
   • Stop writing classes
   • The hexagon pattern (microservices)
   • The C4 Model for system architecture

This two day course covers Full Stack Security with the Defence in Depth approach. It covers important security principles, and mitigating specific vulnerabilities including The OWASP Top Ten, but is focused on secure Python web application development.

• Secure Python Web Application Development

Course Contents

This is a practical and hands on, two day, course. Learn how to use the security tools that come in the Python standard library. Modules covered include:

• hashlib
• hmac
• secrets
• random
• socket
• ssl

Web application frameworks:

• Security features in web application frameworks for API servers and web applications
• How to secure data in Django, Flask and other popular web application frameworks
• Secure deployment practises with containers and application servers (WSGI or ASGI)

Third party libraries for cryptography and secure network access:

• authlib
• cryptography
• httpx and requests
• websocket
• jwt
• OpenZiti for application level zero trust architecture
• certifi for TLS certification verification

Tooling for secure Python development and as part of your CI pipelines:

• uv/pipenv
• pip-audit
• bandit
• ruff
• mypy
• dependabot/renovate
• Security testing

Network security with TLS:

• How, why and when to use TLS
• How TLS works
• mTLS for enhanced security
• Generating self-signed certificates for local development, with the cryptography library

Michael Foord has been a Python application developer for over twenty years, is a Python core developer and the creator of unittest.mock in the Python standard library, and is the author of The Absolute Minimum Every Python Web Application Developer Must Know About Security.

Topics Covered: Core Python Security Fundamentals

• Security principles and defence in depth strategies with Python frameworks
• Implementing OWASP Top 10 protections in Django, Flask and FastAPI applications
• Security principles and defence in depth strategies
• Principles from The OWASP Web Security Testing Guide
• Threat modelling and the security requirements document
• The principles of least privilege and deny by default
• Zero trust architecture fundamentals
• Building zero trust architecture with OpenZiti’s Python SDK

Cryptography and Data Security

• Hashing, encryption, and digital signatures
• Symmetric encryption and public key encryption
• Secure password storage and management
• Using Python’s hashlib and hmac modules for secure hashing
• Using Python’s cryptography libraries correctly
• Data encryption at rest and in transit
• Data encryption at rest using Django’s encrypted model fields and SQLAlchemy StringEncryptedType

Authentication and Authorization

• Secure session management
• OAuth 2.0 and JWT for authentication
• Oauth2 with the Python library authlib
• JWT handling with PyJWT and managing token lifecycles
• Role-based access control (RBAC), plus alternatives
• Multi-factor authentication
• Managing access tokens and permissions

Secure Coding Practices

• Proven security with modern cryptography algorithms
• Protection against SQL injection
• Input validation and sanitisation
• Using secrets vs random for cryptographic operations
• Sanitizing logs in Python applications
• Django template escaping and Flask/Jinja2 for XSS prevention
• Preventing timing attacks and token prediction attacks
• Cryptographically secure randomness
• Cross-site scripting (XSS) prevention
• Cross-site request forgery (CSRF) protection
• Secure file handling and upload validation
• Preventing TLS downgrade attacks

Network Security

• Networking fundamentals
• TLS/SSL implementation and certificate management
• Secure API design and implementation
• WebSocket security
• Network architecture and segmentation
• Firewalls, routers, network interfaces
• Protocols, HTTP & TLS, with the Python standard library
• Application deployment
• Software Defined Networking

Infrastructure Security

• Container security best practices
• Secure deployment patterns
• Network interfaces and routing
• Building DMZ architectures for Python web applications
• Virtual private networks (VPN)

Security Tools and Testing

• Static analysis with bandit and ruff
• Dependency scanning using pip-audit
• Automated security testing integration
• Container scanning and runtime protection
• Code review practices for security

Operational Security

• Live security alerts
• Statutory duties around security
• Monitoring Python applications for security issues
• Security patch management for Python applications
• Updating and patching strategies

The course includes practical exercises throughout, with participants implementing secure coding patterns, identifying vulnerabilities in sample code, and building secure components.

The latest issue of the Free Software Bulletin is now online. We've got a line-up of articles about abandonware traps, tools for cleaning up the Internet, and more!

The latest issue of the Free Software Bulletin is now online. We've got a line-up of articles about abandonware traps, tools for cleaning up the Internet, and more!

Boost is a very large and comprehensive set of (peer-reviewed) libraries for the C++ programming language, containing well over one hundred individual libraries. The BH package provides a sizeable subset of header-only libraries for (easier, no linking required) use by R. It is fairly widely used: the (partial) CRAN mirror logs (aggregated from the cloud mirrors) show over 38.5 million package downloads.

Version 1.87.0 of Boost was released last week following the regular Boost release schedule of April, August and December releases. As before, we packaged it almost immediately and started testing following our annual update cycle which strives to balance being close enough to upstream and not stressing CRAN and the user base too much. The reverse depends check revealed six packages requiring changes or adjustments. We opened issue #103 to coordinate the issue (just as we did in previous years). Our sincere thanks to Matt Fidler who fixed two packages pretty much immediately.

As I had not heard back from the other maintainers since filing the issue, I uploaded the package to CRAN suggesting that the coming winter break may be a good opportunity for the four other packages to catch up. CRAN concurred, and 1.87.0-1 is now available there.

There are no other changes apart from cosmetics in the DESCRIPTION file. For once, we did not add any new Boost libraries. The short NEWS entry follows.

Changes in version 1.87.0-1 (2024-12-17)

• Upgrade to Boost 1.87.0, patched as usual to comment-out diagnostic suppression messages per the request of CRAN

• Switched to Authors@R

Via my CRANberries, there is a diffstat report relative to the previous release. Comments and suggestions about BH are welcome via the issue tracker at the GitHub repo.

This post by Dirk Eddelbuettel originated on his Thinking inside the box blog. If you like this or other open-source work I do, you can now sponsor me at GitHub.

#660 – DECEMBER 17, 2024
View in Browser »

PyMyFlySpy: Track Your Flight Using Its Headrest Data

Robert is the creator of PySkyWiFi, a “completely free, unbelievably stupid wi-fi on long-haul flights” and he is back. This time getting flight data information if you aren’t on a plane with seat-back monitors showing you where you are.
ROBERT HEATON

Python Set Comprehensions: How and When to Use Them

In this tutorial, you’ll learn how to write set comprehensions in Python. You’ll also explore the most common use cases for set comprehensions and learn about some bad practices that you should avoid when using them in your code.
REAL PYTHON

Free Workshop: Temporal 101 With Python

🚀 Unlock power of Temporal in our Python 101 Workshop on January 8th! Join us to explore how to build resilient workflows effortlessly, handle complex scenarios, and automate tasks like a pro. Perfect for developers of all skill levels. Reserve your spot and elevate your coding game →
TEMPORAL TECHNOLOGIES sponsor

Typed Python in 2024

This article discusses the results from a survey on the usage of Typing features in Python. It discusses how much the feature has been adopted and what stands in coders’ way of using it.
AARON POLLACK

JupyterLab 4.3 and Notebook 7.3 Are Available!

JUPYTER.ORG

PEP 757: C API to Import-Export Python Integers (Accepted)

PYTHON.ORG

NumPy Release 2.2.0

GITHUB.COM/NUMPY

PSF Year End Fundraiser / Membership Drive

PYTHON.ORG

Articles & Tutorials Check if a Point Is in a Cylinder

Luke’s current project requires a fair amount of geometry. He wasn’t happy with solutions posted on the web so her wrote his own. This article covers the geometry involved in finding if a point is in a cylinder and the corresponding Python code to do the calculation.
LUKE PLANT

Build Your Own AI Assistant with Edge AI

Simplify workloads and elevate customer service. Build customized AI assistants that respond to voice prompts with powerful language and comprehension capabilities. Personalized AI assistance based on your unique needs with Intel’s OpenVINO toolkit.
INTEL CORPORATION sponsor

Customising Pattern Matching Behaviour

Jamie has been doing the Advent of Code and two techniques that come up a lot in Python are iteration and pattern matching. This post talks about how they don’t work well together and what you can do about it.
JAMIE CHANG

Major Releases of Plotly and Dash

Four of Plotly’s open-source libraries are getting major releases. Includes: lightning-fast server-side performance with Narwhals in Plotly.py, a new hooks system for Dash, a new design for Kaleido, and more.
PLOTLY.COM • Shared by Marco Gorelli

The State of Python 2024

This is a guest post on the PyCharm blog by Talk Python host Michael Kennedy who talks about the current state of Python in 2024. Topics include language usage, web frameworks, uv, and more.
MICHAEL KENNEDY

PEP 768: Safe External Debugger Interface for CPython

“This PEP proposes adding a zero-overhead debugging interface to CPython that allows debuggers and profilers to safely attach to running Python processes.”
PYTHON.ORG

Trusted Publishing

It has never been easier to publish your Python packages. This post explains how to setup a workflow that uses Trusted Publishing through GitHub Actions.
CHRISTIAN LEDERMANN

Lazy Self-Installing Python Scripts With uv

This post talks about how to manage all of your one-off small scripts using uv, especially if they have need of third party libraries.
TREY HUNNER

Django 2024 Year in Review

Carlton is a core contributor to Django and this post talks about what happened in 2024 with your favorite web framework.
CARLTON GIBSON

Multimodal Data With LanceDB

Talk Python interviews Chang She and they talk about LanceDB, and open source database for AI.
KENNEDY & SHE podcast

Write pydantic Testing Models as Dictionaries

GITHUB.COM/KKLUONAITIS • Shared by Karolis Kluonaitis podcast

Projects & Code Bagels: Powerful TUI Expense Tracker

GITHUB.COM/ENHANCEDJAX

moka-py: High Performance Caching Library

GITHUB.COM/DELIRO

ridgeplot: Beautiful Ridgeline Plots in Python

GITHUB.COM/TPVASCONCELOS

ddmin-python: Python Version of Delta Debugging Tool

GITHUB.COM/ANDREWCHAMBERS

django-removals: Check for Django Removals and Deprecations

GITHUB.COM/AMBIENT-INNOVATION

Events Weekly Real Python Office Hours Q&A (Virtual)

December 18, 2024
REALPYTHON.COM

PyData Bristol Meetup

December 19, 2024
MEETUP.COM

PyLadies Dublin

December 19, 2024
PYLADIES.COM

Chattanooga Python User Group

December 20 to December 21, 2024
MEETUP.COM

PyKla Monthly Meetup

December 25, 2024
MEETUP.COM

SPb Python Drinkup

December 26, 2024
MEETUP.COM

Happy Pythoning!
This was PyCoder’s Weekly Issue #660.
View in Browser »

[ Subscribe to 🐍 PyCoder’s Weekly 💌 – Get the best Python news, articles, and tutorials delivered to your inbox once a week >> Click here to learn more ]

Automatically update a spreadsheet of active products Anonymous (not verified) Tue, 12/17/2024 - 07:00 Tags Drupal Website management E-Commerce Drupal Planet

• Read more about Automatically update a spreadsheet of active products
• Add new comment

One of our e-commerce clients has several thousand active products. As a distributor, their clients are retailers, some of which like having an up-to-date product spreadsheet.

Using the Events, Conditions, and Actions (ECA) module along with a Views Data Export view of all products, we created a view of all the relevant fields that exports a spreadsheet of all their products, and saves it in their private media system once per day.

Sockets and the socket API are used to send messages across a network. They provide a form of inter-process communication (IPC). The network can be a logical, local network to the computer, or one that’s physically connected to an external network with its own connections to other networks. The obvious example is the Internet, which you connect to via your ISP.

In this video course, you’ll create:

• A simple socket server and client
• An improved version that handles multiple connections simultaneously
• A server-client application that functions like a full-fledged socket application, complete with its own custom header and content

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

Qt 6.9 brings some useful new features to improve the development process for developers targeting the Android platform. Keep in mind that the following list is not exhaustive of all changes around Qt for Android, and some other features might get their own blog.

Support for Uncompressed Native Libraries

Android 6 and above produces uncompressed native libraries that are only part of the APK by default. However, Qt had this behavior explicitly disabled with the following setting under build.gradle:

android {
...
   packagingOptions.jniLibs.useLegacyPackaging true
...
}

Or via the now deprecated extractNativeLibs manifest flag, because Qt didn't support loading libraries directly from the APK. With this release, such support for reading and loading shared libraries directly from the APK without having them extracted to disk but rather, map those shared libraries to memory. Qt apps and APIs such as QLibrary and QPluginLoader should work the same as before and iterate libraries under the native libraries' directory.

There are few things to consider when this mode is enabled (it's enabled by default on 6.9+). For example, QCoreApplication::applicationDirPath() would now return a path that points to a shared library filename that's inside the app's APK, usually in the form:

/data/data/package-path/base.apk!/lib/arm64-v8a/libmyapp_arm64_v8a.so

Paths returned by similar API calls might have previously returned a writable path, after this however, the returned paths won't be writable.

Enabling this might increase slightly the total size of produced APKs, but saves on disk space after installation and also on update sizes from the Play Store and slightly faster startups. For more information, see Improvements for smaller app downloads on Google Play.

Apps with the older way using compressed libraries still work as before if the relevant flag is explicitly enabled as mentioned above.

New Command-Line App/Test Runner

When developing for Android, you're expected for the most part to be using an IDE that handles the build and deployment and running the app. That process doesn't need to be that complicated, because of that we've added wrapper scripts that handle that job for you. Especially, on CI environments or if you're one of the people who can get by using a lightweight code editor and a terminal for development, this can be quite handy for you. All you need to do is build your project's APK and run the app as follows:

cd build
qt-cmake -S .. -B . -GNinja
cmake --build . --target apk
MY_ENV_VAR=value ./my_app --install --my_arg value

This last command would handle all the underlying adb commands behind the scenes by installing the app to the device, starting it and printing the logcat of the app, making it a more seamless experience and hassle free. For Windows, the runner has the .bat file extension.

You can pass environment variables directly from your shell so they end up being passed to the app's runtime on the device. The same applies for command line arguments, where arguments not reserved by the runner are passed as app's arguments. For all parameters that the wrapper accepts, call it with --help.

The same applies for auto tests, you would be able to simply do the following:

cd build
QTEST_FUNCTION_TIMEOUT=900000 ./tst_android test_case_1

And that would simply handle everything with androidtestrunner under the hood. In this case, you don't need to manually issue the APK build command because androidtestrunner takes care of that.

CMake Android APIs

We keep improving the integration of Android builds with CMake to make it easier to manage and maintain Android-specific requirements. Here’s what’s new:

Add App Permissions

Managing permissions for Android apps often requires manual edits to the AndroidManifest.xml. The newqt_add_android_permission() function removes this hassle by letting you declare permissions directly within your CMakeLists file. This function still allows auto inclusion of Qt modules' managed permissions. This approach simplifies project management, making it more straightforward by keeping project configurations in one place.

Setting an App's Name and Icon

Setting the app's name is now as simple as specifying it with QT_ANDROID_APP_NAME in your CMake configuration. No more manual setting of the app's name in the AndroidManifest.xml file. Similarly, you can now define your app's icon drawable/mipmap in your project's CMake configuration with QT_ANDROID_APP_ICON. This expects the icon drawables to be under the appropriate Android resource directory hierarchy and the use of QT_ANDROID_PACKAGE_SOURCE_DIR.

Setting Java/Kotlin Compile SDK Level

The new property QT_ANDROID_COMPILE_SDK_VERSION allows you to specify the Android SDK version for compiling Java code. With this property, you can ensure your project is always built against the desired API level.

Improved Background Event Management

Background processes, particularly those involving UI updates, can be a source of performance bottlenecks if not managed properly. To address this, now it's possible for developers to set a maximum limit for queued background UI events by setting the new environment variable QT_ANDROID_BACKGROUND_ACTIONS_QUEUE_SIZE.

This enhancement prevents potential memory overload caused by an excessive number of tasks waiting in the queue. By defining a limit, developers can ensure smoother performance and prevent lagging or unresponsive behavior in their apps.

That's all from me this time! As always, we continue to improve Qt for Android, and we welcome your feedback and suggestions on this blog post or over bugreports.qt.io.

 

The release of version 1.0 of the Open Source AI Definition (OSAID) marks an important milestone on a journey to ensure that AI systems are innovative and aligned with the foundational principles of Open Source: the freedoms to use, study, modify and share.

Drafting a definition through collaboration

The OSAID is a testament to the power of global collaboration. Over the past two years, OSI convened a coalition of stakeholders—developers, data scientists, legal experts, policymakers and end users from all over the world. This diverse group coalesced through in-person workshops, online town halls and intensive co-design sessions to craft version 1.0 of the definition.

Key milestones of 2024

System Analysis: As part of the co-design process, working groups were formed to discuss which AI system components should be required to satisfy the four freedoms for AI. This included assessing how data, models, training methods and legal agreements adhere to Open Source principles. The analysis provided invaluable insights into the gaps that exist in current AI practices and outlined actionable steps to bridge these gaps. It also helped refine the OSAID’s criteria, ensuring they remain both practical and comprehensive.

System Evaluation: Several AI systems were assessed against the OSAID’s criteria. While models like OLMo (AI2), Pythia (Eleuther AI), CrystalCoder (LLM360) and T5 (Google) met the requirements, others like LLaMA2 (Meta), Phi-2 (Microsoft), Mixtral (Mistral) and Grok (X/Twitter) fell short, spotlighting the critical need for transparent frameworks in AI development.  Other models such as BLOOM (BigScience), Starcoder2 (BigCode) and Falcon (TII) would pass if they changed their license. This evaluation process also revealed areas where certain models could improve to better align with Open Source standards, demonstrating the OSAID’s role as a constructive guide for future developments.

Stable Release of OSAID 1.0: After extensive global consultation, OSI released the first stable version of the definition at the All Things Open conference in Raleigh, NC. This marked the culmination of two years of dialogue, research and iteration. The stable release provides a comprehensive framework to evaluate AI systems against the core principles of openness.

Global Endorsements: The OSAID has garnered endorsements from over 20 organizations, including Mozilla Foundation, Eleuther AI, CommonCrawl Foundation and the Eclipse Foundation, alongside support from more than 100 individuals. These endorsements validate the OSAID’s importance and its potential to shape the future of AI development.

Events and conferences

Throughout 2024, OSI actively participated in 23 conferences from around the world to engage with diverse communities. Highlights include FOSDEM (February – Brussels), Columbia Convening on openness and AI (February – New York), Open Source Summit NA (April, Seattle), PyCon (May – Pittsburgh), AI_Dev Europe (June, 2024 – Paris), OSPOs for Good (July, 2024 – New York), KubeCon + AI_dev Hong Kong (August – Hong Kong), Open Source Congress (August – Beijing), Deep Learning Indaba (September – Dakar), India FOSS (September – Bengaluru), Open Source Summit Europe (September – Vienna), Nerdearla (September – Buenos Aires), Training Data in OSAI (October – Paris) and All Things Open (October – Raleigh). A full timeline of in-person and online events is available here.

Publications and voices of the OSAID

The OSI published over 60 blog posts about Open Source AI in 2024. One of the highlights is the Voices of the OSAID series that we ran with stories about a few of the people involved in the Open Source AI Definition co-design process, featuring 10 volunteers who have helped shape and are shaping the definition. These stories highlight the diversity and passion of the community, bringing a human element to the often technical discussions around Open Source and AI.

Press coverage

The work around the Open Source AI Definition was cited over 180 times in the press worldwide, educating and countering misinformation. Our work was featured at The New York Times, The Verge, TechCrunch, ZDNET, InfoWorld, Ars Technica, IEEE Spectrum, MIT Technology Review, among other top media outlets.

Looking ahead

The release of OSAID 1.0 is not the end but the beginning of a new chapter. As we transition into 2025, OSI remains committed to continuing regular updates to the definition and evaluating AI systems and licenses to ensure alignment with Open Source principles.

As the Open Source community moves forward, your involvement is more critical than ever. We encourage more organizations and individuals to endorse and implement the OSAID. By broadening its reach, OSI aims to establish the OSAID as the global benchmark for open AI systems. Together, we can ensure that AI remains a tool for permissionless innovation.

OSI extends its deepest gratitude to the sponsors, volunteers and participants who made 2024 a banner year for Open Source AI. Let’s continue to build a future where technology serves everyone, everywhere. As we celebrate this year’s accomplishments, we look forward to what we can achieve together in 2025 and beyond. Please consider donating or sponsoring the OSI.

I recently saw one of my old branded “stripes” wallpapers in a screenshot of FreeBSD by someone on X, and that triggered me to make a new wallpaper in a similar style.

There was a call for artwork for the next Debian release – Trixie, and I made a modified version of one of my old wallpapers for it. As it was not chosen to be the default in Trixie, I decided to post it here for people who might like it.

It is, like all my wallpapers, a calm non-distracting one. (it is much prettier full-4k-size than in the thumbnail below)

Trixie Tracks

If you like it, you can download it from Debian’s Wiki – in 1920x1080 and 4k versions. There is also a version with the Debian logo there for inspiration if you want to create a custom distribution-branded one.

You can support my work on Patreon, or you can get my book Functional Programming in C++ at Manning if you're into that sort of thing. -->

O Alpha 3, O Alpha 3, how lovely are your branches!

https://www.python.org/downloads/release/python-3140a3/

This is an early developer preview of Python 3.14

Major new features of the 3.14 series, compared to 3.13

Python 3.14 is still in development. This release, 3.14.0a3, is the third of seven planned alpha releases.

Alpha releases are intended to make it easier to test the current state of new features and bug fixes and to test the release process.

During the alpha phase, features may be added up until the start of the beta phase (2025-05-06) and, if necessary, may be modified or deleted up until the release candidate phase (2025-07-22). Please keep in mind that this is a preview release and its use is not recommended for production environments.

Many new features for Python 3.14 are still being planned and written. Among the new major new features and changes so far:

• PEP 649: deferred evaluation of annotations
• PEP 741: Python configuration C API
• PEP 761: Python 3.14 and onwards no longer provides PGP signatures for release artifacts. Instead, Sigstore is recommended for verifiers.
• Improved error messages
• (Hey, fellow core developer, if a feature you find important is missing from this list, let Hugo know.)

The next pre-release of Python 3.14 will be 3.14.0a4, currently scheduled for 2025-01-14.

More resources

• Online documentation
• PEP 745, 3.14 Release Schedule
• Report bugs at https://github.com/python/cpython/issues
• Help fund Python and its community

And now for something completely different

A mince pie is a small, round covered tart filled with “mincemeat”, usually eaten during the Christmas season – the UK consumes some 800 million each Christmas. Mincemeat is a mixture of things like apple, dried fruits, candied peel and spices, and originally would have contained meat chopped small, but rarely nowadays. They are often served warm with brandy butter.

According to the Oxford English Dictionary, the earliest mention of Christmas mince pies is by Thomas Dekker, writing in the aftermath of the 1603 London plague, in Newes from Graues-end: Sent to Nobody (1604):

Ten thousand in London swore to feast their neighbors with nothing but plum-porredge, and mince-pyes all Christmas.

Here’s a meaty recipe from Rare and Excellent Receipts, Experienc’d and Taught by Mrs Mary Tillinghast and now Printed for the Use of her Scholars Only (1678):

15. How to make Mince-pies.

To every pound of Meat, take two pound of beef Suet, a pound of Corrants, and a quarter of an Ounce of Cinnamon, one Nutmeg, a little beaten Mace, some beaten Colves, a little Sack & Rose-water, two large Pippins, some Orange and Lemon peel cut very thin, and shred very small, a few beaten Carraway-seeds, if you love them the Juyce of half a Lemon squez’d into this quantity of meat; for Sugar, sweeten it to your relish; then mix all these together and fill your Pie. The best meat for Pies is Neats-Tongues, or a leg of Veal; you may make them of a leg of Mutton if you please; the meat must be parboyl’d if you do not spend it presently; but if it be for present use, you may do it raw, and the Pies will be the better.

Enjoy the new release

Thanks to all of the many volunteers who help make Python Development and these releases possible! Please consider supporting our efforts by volunteering yourself or through organisation contributions to the Python Software Foundation.

Regards from a snowy and slippery Helsinki,

Your release team,
Hugo van Kemenade
Ned Deily
Steve Dower
Łukasz Langa

This post is a review for Computing Reviews for The science of detecting LLM-generated text , a article published in Communications of the ACM

While artificial intelligence (AI) applications for natural language processing (NLP) are no longer something new or unexpected, nobody can deny the revolution and hype that started, in late 2022, with the announcement of the first public version of ChatGPT. By then, synthetic translation was well established and regularly used, many chatbots had started attending users’ requests on different websites, voice recognition personal assistants such as Alexa and Siri had been widely deployed, and complaints of news sites filling their space with AI-generated articles were already commonplace. However, the ease of prompting ChatGPT or other large language models (LLMs) and getting extensive answers–its text generation quality is so high that it is often hard to discern whether a given text was written by an LLM or by a human–has sparked significant concern in many different fields. This article was written to present and compare the current approaches to detecting human- or LLM-authorship in texts.

The article presents several different ways LLM-generated text can be detected. The first, and main, taxonomy followed by the authors is whether the detection can be done aided by the LLM’s own functions (“white-box detection”) or only by evaluating the generated text via a public application programming interface (API) (“black-box detection”).

For black-box detection, the authors suggest training a classifier to discern the origin of a given text. Although this works at first, this task is doomed from its onset to be highly vulnerable to new LLMs generating text that will not follow the same patterns, and thus will probably evade recognition. The authors report that human evaluators find human-authored text to be more emotional and less objective, and use grammar to indicate the tone of the sentiment that should be used when reading the text–a trait that has not been picked up by LLMs yet. Human-authored text also tends to have higher sentence-level coherence, with less term repetition in a given paragraph. The frequency distribution for more and less common words is much more homogeneous in LLM-generated texts than in human-written ones.

White-box detection includes strategies whereby the LLMs will cooperate in identifying themselves in ways that are not obvious to the casual reader. This can include watermarking, be it rule based or neural based; in this case, both processes become a case of steganography, as the involvement of a LLM is explicitly hidden and spread through the full generated text, aiming at having a low detectability and high recoverability even when parts of the text are edited.

The article closes by listing the authors’ concerns about all of the above-mentioned technologies. Detecting an LLM, be it with or without the collaboration of the LLM’s designers, is more of an art than a science, and methods deemed as robust today will not last forever. We also cannot assume that LLMs will continue to be dominated by the same core players; LLM technology has been deeply studied, and good LLM engines are available as free/open-source software, so users needing to do so can readily modify their behavior. This article presents itself as merely a survey of methods available today, while also acknowledging the rapid progress in the field. It is timely and interesting, and easy to follow for the informed reader coming from a different subfield.

If you’re looking to build your website’s authority and improve your SEO rankings, learn about the difference between off-page and on-page SEO, plus strategies that work around the clock.

Mozilla is the maker of the famous Firefox web browser and the birthplace of the likes of Rust and Servo (read more about Embedding the Servo Web Engine in Qt).

Firefox is a huge, multi-platform, multi-language project with 21 million lines of code back in 2020, according to their own blog post. Navigating in projects like those is always a challenge, especially at the cross-language boundaries and in platform-specific code.

To improve working with the Firefox code-base, Mozilla hosts an online code browser tailored for Firefox called Searchfox. Searchfox analyzes C++, JavaScript, various IDLs (interface definition languages), and Rust source code and makes them all browsable from a single interface with full-text search, semantic search, code navigation, test coverage report, and git blame support. It’s the combination of a number of projects working together, both internal to Mozilla (like their Clang plugin for C++ analysis) and external (such as rust-analyzer).

It takes a whole repository in and separately indexes C++, Rust, JavaScript and now Java and Kotlin source code. All those analyses are then merged together across platforms, before running a cross-reference step and building the final index used by the web front-end available at searchfox.org.

Mozilla asked KDAB to help them with adding Java and Kotlin support to Searchfox in prevision of the merge of Firefox for Android into the main mozilla-central repository and enhance their C++ support with macro expansions. Let’s dive into the details of those tasks.

Java/Kotlin Support

Mozilla merged the Firefox for Android source code into the main mozilla-central repository that Searchfox indexes. To add support for that new Java and Kotlin code to Searchfox, we reused open-source tooling built by Sourcegraph around the SemanticDB and SCIP code indexing formats. (Many thanks to them!)

Sourcegraph’s semanticdb-javac and semanticdb-kotlinc compiler plugins are integrated into Firefox’s CI system to export SemanticDB artifacts. The Searchfox indexer fetches those SemanticDB files and turns them into a SCIP index, using scip-semanticdb. That SCIP index is then consumed by the existing Searchfox-internal scip-indexer tool.

In the process, a couple of upstream contributions were made to rust-analyzer (which also emits SCIP data) and scip-semanticdb.

A few examples of Searchfox at work:

• Searching for the Java class: org.mozilla.geckoview.GeckoSession$PromptDelegate$AutocompleteRequest shows the definition, a superclass, some uses in Java source code and some uses in Kotlin tests.
• Searching for the Java interface method: org.mozilla.geckoview.Autocomplete$StorageDelegate$onAddressFetch shows the definition, a couple of users, and a couple of implementers across Java and Kotlin code.
• Querying the callers of a method with up to 2 indirections: calls-to:’org::mozilla::geckoview::Autofill::Session::getDefaultDimensions’ depth:2

If you want to dive into more details, see the feature request on Bugzilla, the implementation and further discussion on GitHub and the release announcement on the mozilla dev-platform mailing list.

Java/C++ Cross-language Support

GeckoView is an Android wrapper around Gecko, the Firefox web engine. It extensively uses cross-language calls between Java and C++.

Searchfox already had support for cross-language interfaces, thanks to its IDL support. We built on top of that to support direct cross-language calls between Java and C++.

First, we identified the different ways the C++ and Java code interact and call each other. There are three ways Java methods marked with the native keyword call into C++:

• Case A1: By default, the JVM will search for a matching C function to call based on its name. For instance, calling org.mozilla.gecko.mozglue.GeckoLoader.nativeRun from Java will call Java_org_mozilla_gecko_mozglue_GeckoLoader_nativeRun on the C++ side.
• Case A2: This behavior can be overridden at runtime by calling the JNIEnv::RegisterNatives function on the C++ side to point at another function.
• Case A3: GeckoView has a code generator that looks for Java items decorated with the @WrapForJNI and native annotations and generates a C++ class template meant to be used through the Curiously Recurring Template Pattern. This template provides an Init static member function that does the right JNIEnv::RegisterNatives calls to bind the Java methods to the implementing C++ class’s member functions.

We also identified two ways the C++ code calls Java methods:

• Case B1: directly with JNIEnv::Call… functions.
• Case B2: GeckoView’s code generator also looks for Java methods marked with @WrapForJNI (without the native keyword this time) and generates a C++ wrapper class and member functions with the right JNIEnv::Call… calls.

Only the C++ side has the complete view of the bindings; so that’s where we decided to extract the information from, by extending Mozilla’s existing Clang plugin.

First, we defined custom C++ annotations bound_as and binding_to that the clang plugin transforms into the right format for the cross-reference analysis. This means we can manually set the binding information:

class __attribute__((annotate("binding_to", "jvm", "class", "S_jvm_sample/Jni#"))) CallingJavaFromCpp { __attribute__((annotate("binding_to", "jvm", "method", "S_jvm_sample/Jni#javaStaticMethod()."))) static void javaStaticMethod() { // Wrapper code } __attribute__((annotate("binding_to", "jvm", "method", "S_jvm_sample/Jni#javaMethod()."))) void javaMethod() { // Wrapper code } __attribute__((annotate("binding_to", "jvm", "getter", "S_jvm_sample/Jni#javaField."))) int javaField() { // Wrapper code return 0; } __attribute__((annotate("binding_to", "jvm", "setter", "S_jvm_sample/Jni#javaField."))) void javaField(int) { // Wrapper code } __attribute__((annotate("binding_to", "jvm", "const", "S_jvm_sample/Jni#javaConst."))) static constexpr int javaConst = 5; }; class __attribute__((annotate("bound_as", "jvm", "class", "S_jvm_sample/Jni#"))) CallingCppFromJava { __attribute__((annotate("bound_as", "jvm", "method", "S_jvm_sample/Jni#nativeStaticMethod()."))) static void nativeStaticMethod() { // Real code } __attribute__((annotate("bound_as", "jvm", "method", "S_jvm_sample/Jni#nativeMethod()."))) void nativeMethod() { // Real code } };

(This example is, in fact, extracted from our test suite, jni.cpp vs Jni.java.)

Then, we wrote some heuristics that try and identify cases A1 (C functions named Java_…), A3 and B2 (C++ code generated from @WrapForJNI decorators) and automatically generate these annotations. Cases A2 and B1 (manually calling JNIEnv::RegisterNatives or JNIEnv::Call… functions) are rare enough in the Firefox code base and impossible to reliably recognize; so it was decided not to cover them at the time. Developers who wish to declare such bindings could manually annotate them.

After this point, we used Searchfox’s existing analysis JSON format and mostly re-used what was already available from IDL support. When triggering the context menu for a binding wrapper or bound function, the definitions in both languages are made available, with “Go to” actions that jump over the generally irrelevant binding internals.

The search results also display both sides of the bridge, for instance:

• searching for the mozilla::widget::GeckoViewSupport::Open C++ member function links to its Java binding org.mozilla.geckoview.GeckoSession$Window.open.
• searching for the org.mozilla.geckoview.GeckoSession.getCompositorFromNative Java method links to its generated C++ binding mozilla::java::GeckoSession::GetCompositor.

If you want to dive into more details, see the feature request and detailed problem analysis on Bugzilla, the implementation and further discussion on GitHub, and the release announcement on the Mozilla dev-platform mailing list.

Displaying Interactive Macro Expansions

Aside from this Java/Kotlin-related work, we also added support for displaying and interacting with macro expansions. This was inspired by KDAB’s own codebrowser.dev, but improves it to:

• Display all expansion variants, if they differ across platforms or by definition:

Per-platform expansions

Per-definition expansions

• Make macros fully indexed and interactive:

In-macro context menu

This work mainly happened in the Mozsearch Clang plugin to extract macro expansions during the pre-processing stage and index them with the rest of the top-level code.

Again, if you want more details, the feature request is available on Bugzilla and the implementation and further technical discussion is on GitHub.

Summary

Because of the many technologies it makes use of, from compiler plugins and code analyzers written in many languages, to a web front-end written using the usual HTML/CSS/JS, by way of custom tooling and scripts in Rust, Python and Bash, Searchfox is a small but complex and really interesting project to work on. KDAB successfully added Java/Kotlin code indexing, including analyzing their C++ bindings, and are starting to improve Searchfox’s C++ support itself, first with fully-indexed macro expansions and next with improved templates support.

About KDAB

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

Subscribe to KDAB TV for similar informative short video content.

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

The post Improvements to Mozilla’s Searchfox Code Browser appeared first on KDAB.

Review: Iris Kelly Doesn't Date, by Ashley Herring Blake

Series: Bright Falls #3 Publisher: Berkley Romance Copyright: October 2023 ISBN: 0-593-55058-7 Format: Kindle Pages: 381

Iris Kelly Doesn't Date is a sapphic romance novel (probably a romantic comedy, although I'm bad at romance subgenres). It is the third book in the Bright Falls series. In the romance style, it has a new set of protagonists, but the protagonists of the previous books appear as supporting characters and reading this will spoil the previous books.

Among the friend group we were introduced to in Delilah Green Doesn't Care, Iris was the irrepressible loudmouth. She's bad at secrets, good at saying whatever is on her mind, and has zero desire to either get married or have children. After one of the side plots of Astrid Parker Doesn't Fail, she has sworn off dating entirely.

Iris is also now a romance novelist. Her paper store didn't get enough foot traffic to justify staying open, so she switched her planner business to online only and wrote a romance novel that was good enough to get a two-book deal. Now she needs to write a second book and she has absolutely nothing. Her own avoidance of romantic situations is not helping, but neither is her meddling family who are convinced her choices about marriage and family can be overturned with sufficient pestering. She desperately needs to shake up her life, get out of her creative rut, and do something new. Failing that, she'll settle for meeting someone in a bar and having some fun.

Stevie is a barista and actress living in Portland. Six months ago, she broke up with Adri, her creative partner, girlfriend of six years, and the first person with whom she had a serious relationship. More precisely, Adri broke up with her. They're still friends, truly, even though that friendship is being seriously strained by Adri dating Vanessa, another member of their small and close-knit friend group. Stevie has occasionally-crippling anxiety, not much luck in finding real acting roles in Portland, and a desperate desire to not make waves. Ren, the fourth member of their friend group, thinks Stevie needs a new relationship, or at least a fling. That's how Stevie, with Ren as backup and encouragement, ends up at the same bar with Iris.

The resulting dance and conversation was rather fun for both Stevie and Iris. The attempted one-night stand afterwards was a disaster due to Stevie's anxiety, and neither of them expected to see the other again. Stevie therefore felt safe pretending they'd hit it off to get her friends off her back. When Iris's continued restlessness lands her in an audition for Adri's fundraiser play that she also talked Stevie into performing in, this turns into a full-blown fake dating trope.

These books continue to be impossible to put down. I'm not sure what Blake is doing to make the pacing so perfect, but as with the previous books of the series I found this utterly compulsive reading. I started it in the afternoon, took a break in the evening for a few hours, and then finished it at 2am.

I wasn't sure if a book focused on Iris would work as well, but I need not have worried. Iris Kelly Doesn't Date is both more dramatic and more trope-centered than the earlier books, but Blake handles that in a way that fits Iris's personality and wasn't annoying even to a reader like me, who has an aversion to many types of relationship drama. The secret is Stevie, and specifically having the other protagonist be someone with severe anxiety.

No was never a very easy word for Stevie when it came to Adri, when it came to anyone, really. She could handle the little stuff — do you want a soda, have you seen this movie, do you like onions on your pizza — but the big stuff, the stuff that caused disappointed expressions and down-turned mouths... yeah, she sucked at that part. Her anxiety would flare, and she'd spend the next week convinced her friends hated her, she'd die alone and miserable, and wasn't worth a damn to anyone. Then, when said friend or family member eventually got ahold of her to tell her that, no, of course they didn't hate her, why in the world would she think that, her anxiety would crest once again, convincing her that she was terrible at understanding people and could never trust her own brain to make heads or tails of any social situation.

This is a spot-on description of a particular type of anxiety, but also this is the perfect protagonist to pair with Iris. Throughout the series, Iris has always been the ride-or-die friend, the person who may have no idea how to help but who will show up anyway and at least try to distract you. Stevie's anxiety makes Iris feel protective, which reveals one of the best sides of Iris's personality, and then the protectiveness plays off against Iris's own relationship issues and tendency to avoid taking anything too seriously. It's one of those relationships that starts a bit one-sided and then becomes mutually supporting once Stevie gets her feet under her. That's a relationship pattern I really enjoy reading about.

As with the rest of the series, the friendship dynamics are great. Here we get to see two friend groups at work: Iris's, which we've seen in the previous two volumes and which expanded interestingly in Astrid Parker Doesn't Fail, and Stevie's, which is new. I liked all of these people, even Adri in her own way (although she's the hardest to like). The previous happily-ever-afters do get a bit awkward here, but Blake tries to make that part of the plot and also avoids most of the problem of somewhat-boring romantic bliss by spreading the friendship connections a bit wider.

Stevie's friend group formed at orientation at Reed College, and that let me put my finger on another property of this series: essentially all of the characters are from a very specific social class. They're nearly all arts people (bookstore owner, photographer, interior decorator, actress, writer, director), they've mostly gone to college, and while most of them don't have lots of money, there's always at least one person in each friend group with significant wealth. Jordan, from the previous book, is a bit of an exception since she works in a trade (a carpenter), but she still acts like someone from that same social class. It's a bit like reading Jane Austen novels and realizing that the protagonists are drawn from a very specific and very narrow portion of society.

This is not a complaint, to be clear; I have no objections to reading about a very specific social class. But if one has already read lots of books about this class of people, I could see that diminishing the appeal of this series a bit. There are a lot of assumptions baked into the story that aren't really questioned, such as the ubiquity of therapists. (I don't know how Stevie affords one on a barista salary.) There are also some small things in the terminology (therapy speak, for example) and in the specific type of earnestness with which the books attempt to be diverse on most axes other than social class that I suspect may grate a bit for some readers. If that's you, this is your warning.

There is a third-act breakup here, just like the previous volumes. There is also a defense of the emotional punch of third-act breakups in romance novels in the book itself, put into Iris's internal monologue, so I suspect that's the author's answer to critics like myself who don't like the trope. I was less frustrated by this one because it fit the drama level of the protagonists, but I'll also know to expect a third-act breakup in any Blake novel I read in the future.

But, all that said, the summary once again is that I loved this book and could not put it down. Iris is dramatic and occasionally self-destructive but has a core of earnest empathy that makes her easy to like. She's exactly the sort of extrovert who is soothing to introverts rather than draining because she carries the extrovert load of social situations. Stevie is adorably earnest and thoughtful beneath her anxiety. They two of them are wildly different and yet remarkably good together, and I loved reading their story.

Highly recommended, along with the whole series. Start with Delilah Green Doesn't Care; if you like that, you're in for a treat.

Content note: This book is also rather sex-forward and pretty explicit in the sex scenes, maybe a touch more than Astrid Parker Doesn't Fail. If that is or is not your thing in romance novels, be aware going in.

Rating: 9 out of 10

Over the last decade, it has become a common experience to be using a social media app, and to perceive that app as saying something specific to you. This manifests in statements like “Twitter thinks Rudy Giuliani has lost his mind”, “Facebook is up in arms about DEI”, “Instagram is going crazy for this new water bottle”, “BlueSky loves this bigoted substack”, or “Mastodon can’t stop talking about Linux”. Sometimes this will even be expressed with “the Internet” as a metonym for the speaker’s preferred social media: “the Internet thinks that Kate Middleton is missing”.

However, even the smallest of these networks comprises literal millions of human beings, speaking dozens of different languages, many of whom never interact with each other at all. The hot takes that you see from a certain excitable sub-community, on your particular timeline or “for you” page, are not necessarily representative of “the Internet” — at this point, a group that represents a significant majority of the entire human population.

If I may coin a phrase, I will refer to these as “Diffuse, Amorphous, Nebulous, Generalized Internet Takes”, or DANGITs, which handily evokes the frustrating feeling of arguing against them.

A DANGIT is not really a new “internet” phenomenon: it is a specific expression of the availability heuristic.

If we look at our device and see a bunch of comments in our inbox, particularly if those comments have high salience via being recent, emotive, and repeated, we will naturally think that this is what The Internet thinks. However, just because we will naturally think this does not mean that we will accurately think it.

It is worth keeping this concept in mind when participating in public discourse because it leads to a specific type of communication breakdown. If you are arguing with a DANGIT, you will feel like you are arguing with someone with incredibly inconsistent, hypocritical, and sometimes even totally self-contradictory views. But to be self-contradictory, one needs to have a self. And if you are arguing with 9 different people from 3 different ideological factions, all making completely different points and not even taking time to agree on the facts beforehand, of course it’s going to sound like cacophonous nonsense. You’re arguing with the cacophony, it’s just presented to you in a way that deceives you into thinking that it’s one group.

There are subtle variations on this breakdown; for example, it can also make people’s taste seem incoherent. If it seems like one week the Interior Designer internet loves stark Scandinavian minimalism, and the next week baroque Rococo styles are making a comeback, it might seem like The Internet has no coherent sense of taste, and these things don’t go together. That’s because it doesn’t! Why would you expect it to?

Most likely, you are simply seeing some posts from minimalists, and then, separately, some posts from Rococo aficionados. Any particular person’s feed may be dedicated to a specific, internally coherent viewpoint, aesthetic, or ideology, but if you dump them all into a blender to separate them from their context, of course they will look jumbled together.

This is what social media does. It is context collapse as a service. Even if you eliminate engagement-maximizing algorithms and view everything perfectly chronologically, even if you have the world’s best trust & safety team making sure that there is nothing harmful and no disinformation, social media — like email — inherently remains that context-collapsing blender. There’s no way for it not to be; if two people you follow, who do not follow and are not aware of each other, are both posting unrelated things at the same time, you’re going to see them at around the same time.

Do not argue with a DANGIT. Discussions are the internet are famously Pyrrhic battles to begin with, but if you argue with a DANGIT it’s not that you will achieve a Pyrrhic victory, you cannot possibly achieve any victory, because you are shadowboxing an imagined consensus where none exits.

You can’t win against something that isn’t there.

Acknowledgments

Thank you to my patrons who are supporting my writing on this blog. If you like what you’ve read here and you’d like to read more things like it, or you’d like to support my various open-source endeavors, you can support my work as a sponsor!