Language Selection

English French German Italian Portuguese Spanish

Web

The Demise of Chromium as Free Software

Filed under
Google
Web
  • This is why Leading Linux Distros going to remove Chromium from their Official Repositories

    Jochen Eisinger from Google team mentioned in a discussion thread that they will be banning sync support system of Chromium. This lead to lot of frustration in the Linux Dev community & rage against googles sudden decision.
    This Decision can kill small browser projects & lead the web to single browser monopoly i.e. Google Chrome!

    As a result of the googles decision multiple distros are strictly considering removal of Chromium from their official repositories. Leading distros like Arch Linux, Fedora, Debian, Slackware & OpenSUSE have stated that if the sync support goes down from google they will definitely remove chromium from their official repositories.

  • Chromium 88 removes Flash support [Ed: But DRM added]

    I uploaded a set of chromium packages to my repository today. Chromium 88.0.4324.96 sources were released two days ago.

    The release notes on the Google Chrome Releases Blog mention 36 security fixes with at least one being tagged as “critical” but the article does not mention that Flash support has been entirely removed from Chromium now.

    Adobe’s Flash was already actively being blocked for a long time and you had to consciously enable Flash content on web pages, but after Adobe discontinued Flash on 1st of January 2021 it was only a matter of time before support in web browsers would be removed as well.

    Let’s also briefly revisit the topic of my previous post – Google will remove access to Chrome Sync for all community builds of the open source variant of their Chrome browser: Chromium… thereby crippling it as far as I am concerned.

  • Chrome 89 Preparing To Ship With AV1 Encoder For WebRTC Usage [Ed: Massive patent trap]

    Now that Chrome 88 released, attention is turning to Chrome 89 of which an interesting technical change is the enabling of AV1 encode support within the web browser.

    Going back to 2018 there's been AV1 decode support within the browser when wanting to enjoy content encoded in this royalty-free, modern codec. But now for Chrome 89 is coming AV1 encode support.

    AV1 encode support is being added for the WebRTC use-case for real-time conferencing. Web applications like WebEx, Meet, and Duo (among others) already support using AV1 for better compression efficiency, improved low-bandwidth handling, and greater screen sharing efficiency. While hardware-based AV1 encoding isn't yet common, Chrome Linux/macOS/Windows desktop builds are adding the ability to use CPU-based AV1 encoding.

Mozilla: Bugs, Fuzzing, Promoted Add-ons Pilot Wrap-up, Greenwashing, and Tor Browser 10.5a7

Filed under
Moz/FF
Web
  • How to Change Firefox Frame Rate for High Refresh Rate Monitor

    Running Ubuntu with high refresh rate monitor? You may found that the Firefox web browser does not match with your monitor’s native refresh rate.

    This is a simple tip shows how to change the refresh rate of Firefox, though you have to first set the system refresh rate (Settings -> Displays) to match your monitor.

  • Analyzing Bugzilla Testcases with Bugmon

    As a member of Mozilla’s fuzzing team, our job is not only to find bugs, but to do what we can to help get those bugs fixed as quickly as possible.

    [...]

    Fuzzing is, in its most basic form, the process of supplying random bits of data to an application in the hopes of triggering unexpected behavior. In relation to Mozilla and those of us fuzzing Firefox, this random data often comes in the form of JavaScript, HTML, CSS, etc., and the unexpected behavior we’re looking for, often presents itself in the form of application crashes or fatal assertions.

    [...]

    While the information provided by Bugmon is certainly helpful in getting bugs fixed quicker, there are a number of features we’d still like to implement.

    Improvements to the bisection analysis stages may allow us to identify regressions down to a single code change. In these cases, we can automatically update the relevant regression fields which can then be leveraged by other Mozilla bots such as autonag. Additionally, we can automate requests for review by the author of the previously identified code change as they may likely be the best candidate to fix it.

    Finally, one often requested feature is to include support for recording bugs with rr. For those unfamiliar with rr; it is a timeless debugger which allows us to record application failures and replay them deterministically. In combination with pernosco, a web-based rr session browser, we can get these recordings into the hands of developers instantly and without any required setup on their part. Thus, reducing the overhead associated with hard to reproduce or intermittent bugs.

  • Mozilla Addons Blog: Promoted Add-ons Pilot Wrap-up

    A few months ago, we launched a pilot for a new program to help developers promote their extensions on addons.mozilla.org (AMO). The main goal of this program was to increase the number of add-ons that our staff can review and verify as compliant with Mozilla policies and provide developers with options for boosting their discoverability on AMO.

    For the pilot, we tested one iteration of how this type of program might work. Pilot developers would have their add-ons manually reviewed for policy compliance. After successfully passing manual review, the pilot add-ons received a Verified badge on their AMO listing page and in the Firefox Add-ons Manager (about:addons), while we removed the standard warning label about the risks of installing third party software.

  • Mozilla’s Climate Commitments [Ed: Mozilla now resorting to mindless greenwashing as they have no clue how to salvage themselves]

    We can’t save the planet without people, and we understand that the internet is an incredibly powerful tool to help us draw the attention to what needs to happen.

    The first line of order is that Mozilla assumes responsibility for its greenhouse gas emissions: We will reduce our emissions significantly and mitigate what we can’t avoid. We will share what we learn and lead transparently, supporting others on their journeys and continuously exploring ways to increase the resiliency of our communities.

  • New Release: Tor Browser 10.5a7

    Tor Browser 10.5a7 is now available from the Tor Browser Alpha download page and also from our distribution directory.

    Note: This is an alpha release, an experimental version for users who want to help us test new features. For everyone else, we recommend downloading the latest stable release instead.

Google and Mozilla Embrace More Restrictions

Filed under
Google
Moz/FF
Web
  • Extensions in Firefox for Android Update | Mozilla Add-ons Blog

    Starting with Firefox 85, which will be released January 25, 2021, Firefox for Android users will be able to install supported Recommended Extensions directly from addons.mozilla.org (AMO). Previously, extensions for mobile devices could only be installed from the Add-ons Manager, which caused some confusion for people accustomed to the desktop installation flow. We hope this update provides a smoother installation experience for mobile users.

    As a quick note, we plan to enable the installation buttons on AMO during our regularly scheduled site update on Thursday, January 21. These buttons will only work if you are using a pre-release version of Firefox for Android until version 85 is released on Tuesday, January 25.

  • Porting Firefox to Apple Silicon

    The release of Apple Silicon-based Macs at the end of last year generated a flurry of news coverage and some surprises at the machine’s performance. This post details some background information on the experience of porting Firefox to run natively on these CPUs.

    We’ll start with some background on the Mac transition and give an overview of Firefox internals that needed to know about the new architecture, before moving on to the concept of Universal Binaries.

    We’ll then explain how DRM/EME works on the new platform, talk about our experience with macOS Big Sur, and discuss various updater problems we had to deal with. We’ll conclude with the release and an overview of various other improvements that are in the pipeline.

  • Google muzzles all Chromium browsers on 15 March 2021

    What is the relevance I hear you ask.
    Well, I provide Chromium packages for Slackware, both 32bit and 64bit versions. These chromium packages are built on our native Slackware platform, as opposed to the official Google Chrome binaries which are compiled on an older Ubuntu probably, for maximum compatibility across Linux distros where these binaries are used. One unique quality of my Chromium packages for Slackware is that I provide them for 32bit Slackware. Google ceased providing official 32bit binaries long ago.

    In my Slackware Chromium builds, I disable some of the more intrusive Google features. An example: listening all the time to someone saying “OK Google” and sending the follow-up voice clip to Google Search.

    And I create a Chromium package which is actually usable enough that people prefer it over Google’s own Chrome binaries, The reason for this usefulness is the fact that I enable access to Google’s cloud sync platform through my personal so-called “Google API key“. In Chromium for Slackware, you can logon to your Google account, sync your preferences, bookmarks, history, passwords etc to and from your cloud storage on Google’s platform. Your Chromium browser on Slackware is able to use Google’s location services and offer localized content; it uses Google’s translation engine, etcetera. All that is possible because I formally requested and was granted access to these Google services through their APIs within the context of providing them through a Chromium package for Slackware.

    The API key, combined with my ID and passphrase that allow your Chromium browser to access all these Google services are embedded in the binary – they are added during compilation. They are my key, and they are distributed and used with written permission from the Chromium team.

    These API keys are usually meant to be used by software developers when testing their programs which they base on Chromium code. Every time a Chromium browser I compiled talks to Google through their Cloud Service APIs, a counter increases on my API key. Usage of the API keys for developers is rate-limited, which means if an API key is used too frequently, you hit a limit and you’ll get an error response instead of a search result. So I made a deal with the Google Chromium team to be recognized as a real product with real users and an increased API usage frequency. Because I get billed for every access to the APIs which exceeds my allotted quota and I am generous but not crazy.
    I know that several derivative distributions re-use my Chromium binary packages (without giving credit) and hence tax the usage quota on my Google Cloud account, but I cover this through donations, thank you my friends, and no thanks to the leeches of those distros.

Brave Browser Adds Native Support for Decentralized IPFS Protocol

Filed under
Web

Even though Brave browser was caught up in some controversies last year, it looks like they managed to become the first major web browser to add support for InterPlantetary File System (IPFS) protocol with the help of Protocol Labs.

This support was introduced with v1.19.86 release.

In case you didn’t know, IPFS is a peer to peer protocol that lets you store and share files. You can safely assume it as something similar to the BitTorrent protocol with some technical differences.

Just because it is totally a decentralized system to store and share files, it can be quite effective to fight censorship by big tech and the government.

Read more

Mozilla: Rust, Socorro, and 'Healthier' Internet (Openwashing)

Filed under
Development
Moz/FF
Web
  • Another Rust-y OS: Theseus joins Redox in pursuit of safer, more resilient systems

    Rust, a modern system programming language focused on performance, safety and concurrency, seems an ideal choice for creating a new operating system, and several such projects already exist. Now there is a new one, Theseus, described by creator Kevin Boos as "an Experiment in Operating System Structure and State Management."

    The key thinking behind Theseus is to avoid what Boos and three other contributors from Rice and Yale universities call "state spill".

  • This Week In Rust: This Week in Rust 373
  • Socorro Engineering: Half in Review 2020 h2 and 2020 retrospective

    2020h1 was rough. 2020h2 was also rough: more layoffs, 2 re-orgs, Covid-19.

    I (and Socorro and Tecken) got re-orged into the Data Org. Data Org manages the Telemetry ingestion pipeline as well as all the things related to it. There's a lot of overlap between Socorro and Telemetry and being in the Data Org might help reduce that overlap and ease maintenance.

    [...]

    2020 sucked. At the end, I was feeling completely demoralized and deflated.

  • Reimagine Open: Building a Healthier Internet

    Does the “openness” that made the [Internet] so successful also inevitably lead to harms online? Is an open [Internet] inherently a haven for illegal speech, for eroding privacy and security, or for inequitable access? Is “open” still a useful concept as we chart a future path for the [Internet]?

    A new paper from Mozilla seeks to answer these questions. Reimagine Open: Building Better Internet Experiences explores the evolution of the open [Internet] and the challenges it faces today. The report catalogs findings from a year-long project of outreach led by Mozilla’s Chairwoman and CEO, Mitchell Baker. Its conclusion: We need not break faith with the values embedded in the open [Internet]. But we do need to return to the original conceptions of openness, now eroded online. And we do need to reimagine the open [Internet], to address today’s need for accountability and online health.

TabFS Makes Your Browser A File System

Filed under
Software
Web

Like Unix, old-fashioned Linux has the philosophy that everything should look like a file. That paradigm works well and most of the operating system’s core features follow that pattern. However, many modern additions don’t really treat things as files or, at least, not files you can easily manipulate with the other tools. [Omar Rizwan] has a handy Chrome extension, though, that will make your browser tabs look like part of your file system. Not only is it a novel idea, but it is also surprisingly handy.

The extension feels like a bit of a proof of concept, so installation is a bit rough, but it does work and it allows you to do things that you would otherwise have to write an extension or a sophisticated program to screen scrape which is always less than desirable.

Read more

9 Decentralized, P2P and Open Source Alternatives to Mainstream Social Media Platforms Like Twitter, Facebook, YouTube and Reddit

Filed under
Web

Tired of Big Tech prying on your data and invading your privacy? Here are some open source, decentralized alternate social platforms.
Read more

GNU Wget 1.21 and GNU Wget 1.21.1 Released

Filed under
GNU
Web
  • GNU Wget 1.21 Released

    Noteworthy changes in this release:

    Improve the number of translated strings
    Remove all uses of alloca. In some places the length of untrusted strings has been used, e.g. strings from the command line or from remote.
    Fix buffer overflows in progress bar code in some locales
    Fix two null pointer accesses
    Amend cookie file header to be recognized by the 'file' command
    Post Handshake Authentication for OpenSSL
    Require gettext version 0.19.3+
    Add configure flags --enable-fsanitize-ubsan, --enable-fsanitize-asan and --enable-fsanitize-msan for gcc and clang
    Make several smaller fixes, enhance fuzzing, enhance building

  • GNU Wget 1.21.1 Released

    Noteworthy changes in this release:

    Fix compilation on MacOS and Solaris 9
    Remove bashism from configure.ac
    Fix a compilation warning on 32-bit systems

Mozilla Firefox Flips On AVIF Image Decoding By Default

Filed under
Moz/FF
Web

As noted before the holidays that Mozilla Firefox was ready to enable AVIF image decoding by default, now that the holidays have passed and developers back to their keyboards, Firefox today has re-enabled AVIF by default.

Since Google's Chrome 85 there has been AVIF support enabled by default while the Firefox support has been disabled by default for now. But as of today in their nightly code the functionality is there out-of-the-box.

Read more

Also: We need more than deplatforming

19 Free open-source self-hosted Invoicing and billing solutions

Filed under
Server
OSS
Web

In a dynamic business environment invoices are created regularly and require custom workflow according to the enterprise business process.

Invoice and order management solutions are built to manage billing and invoicing documents generally. Some of them manage orders and post-sale subscription billing.

Most of ERP (Enterprise Resources Planning) solutions include invoice, billing and order management features.

Read more

Syndicate content

More in Tux Machines

EasyOS Dunfell 2.6.1 released for x86_64 PC

Yesterday announced EasyOS Dunfell 2.6.1 aarch64 for the Raspberry Pi4: https://bkhome.org/news/202101/easyos-dunfell-261-released-for-the-raspberry-pi4.html Today it is the turn for EasyOS Dunfell-series 2.6.1 64-bit on the PC. This is the first official release in this series. Same packages compiled in OpenEmbedded. Latest SeaMonkey 2.53.6. A different kernel for the PC build, 5.10.11. Read all about it here: http://distro.ibiblio.org/easyos/amd64/releases/dunfell/2.6.1/release-notes-2.6.1.htm As stated in the release notes, all three streams are being sync'ed to the same version number. The Buster-series 2.6.1 will probably be uploaded tomorrow. I have to compile the latest 5.4.x kernel, and SeaMonkey 2.53.6. As to which you would choose for the PC, it is like asking "which is better, strawberry icecream or chocolate icecream?" Read more

Top 20 Uses of Linux

The Linux OS and its related distros and flavors have transformed it from hardcore software into an industrial brand. Even if you are not a fan of it, the Linux OS might be as common as the air you breathe if you closely analyze your day to day interactive activities. Almost all the modern technologies that transform and innovate the tech industry have a Linux OS DNA imprinted on them. Those that are yet to be branded with their innovative uniqueness and recognition are waiting in line for the famed chance. Therefore, you might boldly claim that the Linux OS does not run your life, but the world around you cannot avoid the flirty pursuits of this open-source and free software. Nowadays, almost anything that can be described as cool is either pursuing Linux or is being pursued by Linux. It is the perfect symbiotic relationship in a world that tries to find a balance in technology and innovation. This article explores the awesomeness and outreach of the Linux OS in the world around us. It might even be an eye-opener for some of us to start taking our Linux skills to the next level. Top500 quotes Linux as the powerhouse or engine behind five-hundred fastest computers worldwide. I do not know of the speed of the computer composing this article or whether it qualifies to be among the listed five-hundred fastest computers worldwide. However, one thing is certain; it is 100% Linux DNA. On this note, let us start parading the top 20 uses of Linux. Read more

parted-3.4 released [stable]

Parted 3.4 has been released.  This release includes many bug fixes and new features. 
Here is Parted's home page: 
    http://www.gnu.org/software/parted/ 
For a summary of all changes and contributors, see: 
  https://git.savannah.gnu.org/cgit/parted.git/log/?h=v3.4 
or run this command from a git-cloned parted directory: 
  git shortlog v3.3..v3.4 (appended below) 
Here are the compressed sources and a GPG detached signature[*]: 
  http://ftp.gnu.org/gnu/parted/parted-3.4.tar.xz 
  http://ftp.gnu.org/gnu/parted/parted-3.4.tar.xz.sig 
Use a mirror for higher download bandwidth: 
  https://www.gnu.org/order/ftp.html 
[*] Use a .sig file to verify that the corresponding file (without the 
.sig suffix) is intact.  First, be sure to download both the .sig file 
and the corresponding tarball.  Then, run a command like this: 
  gpg --verify parted-3.4.tar.xz.sig 
If that command fails because you don't have the required public key, 
then run this command to import it: 
  gpg --keyserver keys.gnupg.net --recv-keys 117E8C168EFE3A7F 
and rerun the 'gpg --verify' command. 
This release was bootstrapped with the following tools: 
  Autoconf 2.69 
  Automake 1.16.1 
  Gettext 0.21 
  Gnulib v0.1-4131-g252c4d944a 
  Gperf 3.1 
Read more

Kernel: LWN's Latest and IO_uring Patches

  • Resource limits in user namespaces

    User namespaces provide a number of interesting challenges for the kernel. They give a user the illusion of owning the system, but must still operate within the restrictions that apply outside of the namespace. Resource limits represent one type of restriction that, it seems, is proving too restrictive for some users. This patch set from Alexey Gladkov attempts to address the problem by way of a not-entirely-obvious approach. Consider the following use case, as stated in the patch series. Some user wants to run a service that is known not to fork within a container. As a way of constraining that service, the user sets the resource limit for the number of processes to one, explicitly preventing the process from forking. That limit is global, though, so if this user tries to run two containers with that service, the second one will exceed the limit and fail to start. As a result, our user becomes depressed and considers a career change to goat farming. Clearly, what is needed is a way to make at least some resource limits apply on per-container basis; then each container could run its service with the process limit set to one and everybody will be happy (except perhaps the goats).

  • Fast commits for ext4

    The Linux 5.10 release included a change that is expected to significantly increase the performance of the ext4 filesystem; it goes by the name "fast commits" and introduces a new, lighter-weight journaling method. Let us look into how the feature works, who can benefit from it, and when its use may be appropriate. Ext4 is a journaling filesystem, designed to ensure that filesystem structures appear consistent on disk at all times. A single filesystem operation (from the user's point of view) may require multiple changes in the filesystem, which will only be coherent after all of those changes are present on the disk. If a power failure or a system crash happens in the middle of those operations, corruption of the data and filesystem structure (including unrelated files) is possible. Journaling prevents corruption by maintaining a log of transactions in a separate journal on disk. In case of a power failure, the recovery procedure can replay the journal and restore the filesystem to a consistent state. The ext4 journal includes the metadata changes associated with an operation, but not necessarily the related data changes. Mount options can be used to select one of three journaling modes, as described in the ext4 kernel documentation. data=ordered, the default, causes ext4 to write all data before committing the associated metadata to the journal. It does not put the data itself into the journal. The data=journal option, instead, causes all data to be written to the journal before it is put into the main filesystem; as a side effect, it disables delayed allocation and direct-I/O support. Finally, data=writeback relaxes the constraints, allowing data to be written to the filesystem after the metadata has been committed to the journal. Another important ext4 feature is delayed allocation, where the filesystem defers the allocation of blocks on disk for data written by applications until that data is actually written to disk. The idea is to wait until the application finishes its operations on the file, then allocate the actual number of data blocks needed on the disk at once. This optimization limits unneeded operations related to short-lived, small files, batches large writes, and helps ensure that data space is allocated contiguously. On the other hand, the writing of data to disk might be delayed (with the default settings) by a minute or so. In the default data=ordered mode, where the journal entry is written only after flushing all pending data, delayed allocation might thus delay the writing of the journal. To assure data is actually written to disk, applications use the fsync() or fdatasync() system calls, causing the data (and the journal) to be written immediately.

  • MAINTAINERS truth and fiction

    Since the release of the 5.5 kernel in January 2020, there have been almost 87,000 patches from just short of 4,600 developers merged into the mainline repository. Reviewing all of those patches would be a tall order for even the most prolific of kernel developers, so decisions on patch acceptance are delegated to a long list of subsystem maintainers, each of whom takes partial or full responsibility for a specific portion of the kernel. These maintainers are documented in a file called, surprisingly, MAINTAINERS. But the MAINTAINERS file, too, must be maintained; how well does it reflect reality? The MAINTAINERS file doesn't exist just to give credit to maintainers; developers make use of it to know where to send patches. The get_maintainer.pl script automates this process by looking at the files modified by a patch and generating a list of email addresses to send it to. Given that misinformation in this file can send patches astray, one would expect it to be kept up-to-date. Recently, your editor received a suggestion from Jakub Kicinski that there may be insights to be gleaned from comparing MAINTAINERS entries against activity in the real world. A bit of Python bashing later, a new analysis script was born.

  • Experimental Patches Allow For New Ioctls To Be Built Over IO_uring

    IO_uring continues to be one of the most exciting technical innovations in the Linux kernel in recent years not only for more performant I/O but also opening up other doors for new Linux innovations. IO_uring has continued adding features since being mainlined in 2019 and now the newest proposed feature is the ability to build new ioctls / kernel interfaces atop IO_uring. The idea of supporting kernel ioctls over IO_uring has been brought up in the past and today lead IO_uring developer Jens Axboe sent out his initial patches. These initial patches are considered experimental and sent out as "request for comments" - they provide the infrastructure to provide a file private command type with IO_uring handling the passing of the arbitrary data.