Layer Modes, sometimes called Blending Modes, allow you to combine layers in a variety of ways. We continue with the HSV Components Modes, which brings us to yet another color model, in this case the Hue, Saturation, and Value model. We've already looked at RGB, which is the model used for most broadcast and online uses, and the CMYK model which is used for printing. These are the Layer Modes available on the latest (at the time I write this) version of GIMP, 2.10.24.

Links:

https://docs.gimp.org/2.10/en/gimp-concepts-layer-modes.html

https://www.linuxtopia.org/online_books/graphics_tools/gimp_advanced_guide/gimp_guide_node55_004.html

https://www.youtube.com/watch?v=17Iivi0tmug&t=1734s

https://en.wikipedia.org/wiki/RGB_color_model

https://en.wikipedia.org/wiki/Subtractive_color

https://en.wikipedia.org/wiki/Color_model

https://en.wikipedia.org/wiki/HSL_and_HSV

https://snappygoat.com/

https://www.ahuka.com/gimp/hsv-components-layer-modes/

In this episode of the Inlaws our two ageing heroes host Doug DeMaio and Axel Braun, both intimately

associated with and actively supporting the OpenSUSE project, the foundation of one of the popular Linux distros

apart from RedHat and Debian for companies of all sizes (yes, and Ubuntu before I get any hate mails

from Mark Shuttleworth or Cannonical in general :-). Apologies for not mentioning Alma, CentOS or

Rocky Linux. Topics of discussion include the advantages of hipster concepts like rolling releases,

the year of the Linux desktop, other people's computers (aka Clouds) and philosophical things like

IT security, all things cloud-native (well, almost) and Apple laptop users drinking fancy coffee

derivatives. Never mind containers, edge-computing operating systems and live kernel patching.

Links:

OpenSUSE: https://www.opensuse.org

SUSE: https://www.suse.com

openQA: https://open.qa

Open Build Service: https://openbuildservice.org

CentOS debacle: https://arstechnica.com/gadgets/2020/12/centos-shifts-from-red-hat-unbranded-to-red-hat-beta

OpenSUSE conference: https://events.opensuse.org

MicroOS: https://microos.opensuse.org

Kubic: https://kubic.opensuse.org

Rancher: https://www.suse.com/products/rancher-kubernetes-engine

OpenSUSE mailing lists: https://lists.opensuse.org/archives

OpenSUSE bar: https://meet.opensuse.org/bar

OpenSUSE social media: https://en.opensuse.org/openSUSE:Social_media_contacts

OpenSUSE IRC: https://en.opensuse.org/openSUSE:IRC_list

Audacity vs. Tenacity

https://www.engadget.com/audacity-privacy-policy-spyware-accusations-data-collection-210001803.html

https://hackaday.com/2021/07/23/new-privacy-policy-gets-audacity-back-on-track

Tenacity project page

https://tenacityaudio.org

Reason for forking the Audacity project

Motivation

Our project initially started as a fork of Audacity as a result of multiple controversies and public relation crises, which you can find out more about here:

Privacy policy which may violate the original project's GPL license

Contributor's License Agreement (CLA) which may violate the same GPL license

Attempts at adding telemetry using Google services for data collection

Nevertheless, the goal of this project is to pick up what the original developers of Audacity the decades-long work by the original creators of Audacity and create an audio editor that is fresh, more modern, convenient and practical to use, with the help and the guidance of our users and our community.

https://github.com/tenacityteam/tenacity#motivation

Community section

https://tenacityaudio.org/#community-buttons

Flatpak nightly build

https://github.com/tenacityteam/tenacity-flatpak-nightly/blob/main/README.md

flatpak remote-add tenacity oci+https://tenacityteam.github.io/tenacity-flatpak-nightly

flatpak install tenacity org.tenacityaudio.Tenacity

Update Flatpak

flatpak update tenacity org.tenacityaudio.Tenacity

Build instructions for Cmake

https://gist.github.com/ricemark20/17382125f04083b3cdcda3d8bed64e4a

Clone Tenacity from the Tenacity GitHub project.

$ git clone https://github.com/tenacityteam/tenacity/

$ cd tenacity

Configure Tenacity using CMake:

$ mkdir build && cd build

$ cmake -G "Unix Makefiles" -Duse_ffmpeg=loaded ..

By default, Debug build will be configured. To change that, pass -DCMAKE_BUILD_TYPE=Release to CMake.

Build Tenacity:

$ make -j`nproc`

$ sudo make install

Current version:3.0.2-895-g0665614

intro Donation link

what you'll need

hardware

arduino uno or nano

programmer

https://hackerpublicradio.org/eps.php?id=2799

cables

software

flashforth https://www.sourceforge.net/projects/flashforth

avrdude https://www.nongnu.org/avrdude/

terminal program

emacs: M-x serial-term

datasheet

the install

the guide https://flashforth.com/atmega.html

did it work?

troubleshooting

check connections

permission issues

set fuses separately, one at a time

double checkterminal baud rate

hello-world

: hw1 ." Hello, world!" ;

: led-on %00100000 PORTB mset ;

: led-off %00100000 PORTB mclr ;

: flash-led begin led-on #1000 ms led-off #1000 ms again ;

This is a story of a laptop with two power problems.

The first and less severe is that sometimes the charging of the battery will get stuck at a certain percentage. This is not simply due to the effect commonly found with aging batteries but a fault with the laptop's charging hardware. A full reset of the charging system can fix it, which for this ASUS Zenbook UX550vd laptop requires a long press — meaning 40 seconds — from its shutdown state.

The second and more serious issue is that the laptop thinks that it is plugged into AC power even when it is running only on battery. I ruled out an operating system or software issue because the issue remains whether running GNU/linux or Windows. The problem is serious because the power management software, in my case in KDE, will not respond to critically low battery levels by suspending or gracefully shutting down. It may be that a sudden loss of power damaged the previous SSD in this laptop, which was the subject of HPR 3428.

My first attempt to fool KDE into seeing accurate battery information under /sys/class/power_supply/BAT0 using an overlay filesystem failed presumably because KDE's power system is listening out for some kind of event rather than simply monitoring those files. My second and successful attempt involved writing my own bash scripts run by cron to monitor battery levels and initiate actions when they got too low. There were errors with comedic consequences along the way. In fact, while writing these shownotes after I finished recording the audio, the laptop suspended itself because of a bug in my script - I used le (less than or equal to) rather than lt (less than) in my test for a change in the battery charge leading to unintended and fun consequences when the battery was fully charged.

There's certain amount of boilerplate code in my game that keeps repeating time after time. I can't quite remove it, but I can hide it with template haskell.

newtype recap

I'll be using PlanetName as an example throughout the show. newtype is Haskell's way of defining a new type, that wraps around an old type. This lets us to give better meaning to the wrapped type. Instead of talking about Text, we can talk about PlanetName and we won't accidentally mix it up with StarName or ContentsOfAlexandrianLibrary. It comes with no performance cost at all, as the wrapping is removed during the compilation.

Below is how our PlanetName is defined:

newtype PlanetName

= MkPlanetName {_unPlanetName :: Text}

deriving (Show, Read, Eq)

It has:

type constructor PlanetName

data constructor MkPlanetName

single field _unPlanetName

type for that field Text

deriving clause, telling compiler to automatically generate Show, Read and Eq instances

If it were wrapping a Integer, we would add Ord and Num instances too.

These instances give us some basic functions that we can use to turn out value into String and back or compare two values to see if they're equal or not. Ord lets us compare their relative size and Num adds some basic arithmetics like addition and subtraction.

Remember, type constructor is used when talking about the type (function signatures, declaring type of a value, etc.), while data constructor is used to create values of the type ("Earth", "Mars", etc.). isPlanet :: PlanetName -> Bool states that isPlanet function takes one parameter of type PlanetName and returns value of type Bool. planet = MkPlanetName "Earth" creates a new value planet, that has type PlanetName and which value is MkPlanetName "Earth".

Boilerplate

When PlanetName is defined, I need to add some instances by hand: IsString, ToJSON, FromJSON, PersistField and PersistFieldSql.

IsString lets me use string literals in code, without having to call the data constructor. Compiler is smart enough to infer from context if string I typed should be PlanetName or something else.

ToJSON and FromJSON are used to turn value to and from json for transferring back and forth between client and server. In json our value is just simple string, but we still need to program that transformation.

PersistFieldSql tells Persistent (database layer I'm using) what type of database field should be created to hold this data in database.

PersistField contains functions for serializing our value to database and loading it from there.

Below is full code that I want to abstract out as much as I can:

newtype PlanetName

= MkPlanetName {_unPlanetName :: Text}

deriving (Show, Read, Eq)

instance IsString PlanetName where

fromString = (MkPlanetName . fromString)

instance ToJSON PlanetName where

toJSON = (toJSON . _unPlanetName)

instance FromJSON PlanetName where

parseJSON = (withText "PlanetName") (return . MkPlanetName)

instance PersistField PlanetName where

toPersistValue (MkPlanetName s) = PersistText s

fromPersistValue (PersistText s) = (Right $ MkPlanetName s)

fromPersistValue _ = Left "Failed to deserialize"

instance PersistFieldSql PlanetName where

sqlT

In today's show Ken recommends a fairly affordable tool for measuring all sorts of dimensions.

From Wikipedia

Outside large jaws: used to measure external diameter of an object (like a hollow cylinder) or width of an object (like a rod), diameter of an object (like a sphere).

Inside small jaws: used to measure the internal diameter of an object (like a hollow cylinder or pipe).

Depth probe/rod: used to measure depths of an object (like a small beaker) or a hole.

Main scale (Metric): marked every millimeter and helps to measure length correct up to 1 mm.

Main scale (Imperial): marked in inches and fractions.

Vernier scale (Metric) gives interpolated measurements to 0.1 mm or better.

Vernier scale (Imperial) gives interpolated measurements in fractions of an inch.

Retainer: used to block movable part to allow the easy transferring of a measurement.

This is a show about porridge.

Episodes mentioned in this episode:

hpr3272 :: In GNU/Linux, there is no "diversity", we're all just data. hosted by Some Guy On The Internet

hpr3257 :: Lack of diversity in Linux and other open source communities hosted by swift110

hpr3251 :: Opposing Views on Alcohol hosted by Windigo

hpr3247 :: Saturday Morning Automotive Routine hosted by TrumpetJohn

hpr3223 :: My COVID year summary hosted by b-yeezi

hpr3121 :: Opposing Views on Tattoos hosted by Windigo

Island mentioned in this episode: https://en.wikipedia.org/wiki/St_Kilda,_Scotland

All the porridge: https://en.wikipedia.org/wiki/List_of_porridges

By the end of the series I would like to end up with an example repository on Github/Gitlab with scenarios and example configuration file which makes them easy to replicate and modify to your need. I am interested in your opinion what type of service would you fancy to self-host yourself. So don't hesitate to contact me on twitter, matrix.org or in email.

Twitter: @takov751

matrix: takov751:matrix.org

email: [email protected]

Few interesting communities/project:

Community around making a curated list of their own docker images and maintain them:

https://linuxserver.io

Open source project for home automation: https://www.home-assistant.io/

This episode is a quick software recommendation/introduction to Barrier. Barrier is a software KVM, forked from Synergy. It sends your keystrokes and mouse input over the network, so that you can share your input devices between computers.