We started producing shows as Today with a Techie on 2005-09-19, 13 years, 6 months, 4 days ago. Our shows are produced by listeners like you and can be on any topic that "are of interest to hobbyists". If you listen to HPR then please consider contributing one show a year. If you record your show now it could be released in 28 days.
Please help out tagging older shows !
Hallo HPR listeners – in my recent episodes hpr2738 and hpr2746 I talked about some of the applications and software I regularly use as part of my day to day use of Linux Mint. This follow up show will continue with a few more of the same.
CUPS – Common Unix Printing Software; printing in Linux with this utility is fairly well supported, if you don’t have a very recent printer it’s a good chance that CUPS will be able to find a driver for your printer if a Linux one has not been supplied when you bought it or through the manufacturers support site. In the menu just search for print and it will bring up the application for adding a new printer.
Gparted – fully featured disc management tool for formatting and partitioning discs
Document viewer – generic pdf viewer
Software manager
Terminal – apt command for updating the system and installing new software
get_iplayer
To embed text into a Djvu file, you must create a djvused script detailing the page and bitmap location of one of: character, word, line, paragraph, or region.
For good measure, you should first list the contents of your Djvu bundle:
$ djvused -e 'select; ls' test.djvu
1 P 177062 p0001.djvu
2 P 199144 p0002.djvu
3 P 12323 p0003.djvu
4 P 57059 p0004.djvu
5 P 96725 p0005.djvu
6 P 53868 p0006.djvu
Then define the location of text in a file called, for instance, content.dsed. Assume that my page is 1000 px by 1000 px:
select; remove-ant; remove-txt
select "p0004.djvu" # page 4
set-txt
(page 0 0 1000 1000
(word 100 600 450 800 "Hello" )
(word 100 600 450 800 "world" ))
.
select "p0005.djvu"
set-txt
(page 0 0 1000 1000
(line 100 400 900 600 "Hacker Puppy Radio"))
Apply this script to your Djvu file with dvjused:
djvused -f ./content.dsed -s test.djvu
You can convert PDF files to Djvu with the djvudigital command. Due to license incompatibility, it does require you to compile a Ghostscript plugin, but it's an easy build. Get the gsdjvu code, and then follow its README instructions.
Once you've built the Ghostscript driver, you can convert PDF to Djvu:
djvudigital --words foo.pdf foo.djvu
Taxonomy of RPG-related books:
Rulebooks tell you how to play the game.
Optional books of rules add modular components to the base game. They add nuance to specific actions (for example, a book might add rules on owning and managing a castle in a fantasy world, or it might add rules on hacking in a sci fi game; these are things you can do without rules in the game, but if you want added stakes, then these books are ones you would want to obtain).
Adventures (formerly called "modules") provide game plots and locations, in the event that you have no interest in designing your own.
Source books or "settings" provide additional information on the setting of a game, sometimes even providing an alternate game universe with additional rules.
Extra media, like novels, comics, movies, and video games, provide more information (sometimes in canon, sometimes not) about the game universe in which you are playing. Rarely do these have impact on the rules of the game, but they may provide a common language and shared experience for the players.
The only essential purchase is the rulebook. Everything else can be generated by gamers. Purchasing additional material is optional, and can either be seen as a great way to support a company providing your entertainment, or as an insidious plot by greedy corporations to rope you into a perpetual cycle of capitalism. However, RPG is a pretty healthy (and often open) system, so free and open content abounds.
Hosted by NYbill on 2019-03-14 is flagged as Clean and released under a CC-BY-SA license.
Tags: multimeter, electronics, test equipment, hardware review.
Listen in ogg, spx, or mp3 format.
Comments (0)
NYbill does yet another inexpensive multimeter review. This time the AstroAI WH5000A. (Its time for a multimeter intervention!)
The meter:
Pics for the episode:
In episode hpr2748 Writing Web Game in Haskell - Special events, I talked about how to add special events in the game. One drawback with the system presented there was that the kragii worms might attack planet that already had kragii worms present. This time we’ll look into how to prevent this. As a nice bonus, we also come up with system that can be used to record when a planet has particularly good harvest season.
We need a way to represent different kinds of statuses that a planet might have. These will include things like on going kragii attack or a particularly good harvest season. And since these are will be stored in database, we are also going to use derivePersistField to generate code needed for that.
data PlanetaryStatus =
GoodHarvest
| PoorHarvest
| GoodMechanicals
| PoorMechanicals
| GoodChemicals
| PoorChemicals
| KragiiAttack
derivePersistField "PlanetaryStatus"We could have recorded statuses as strings, but declaring a separate data type means that compiler can catch typos for us. It also makes code easier to read as PlanetaryStatus is much more informative than String or Text.
For database, we use following definition shown below in models file. It creates database table planet_status and respective Haskell data type PlanetStatus. There will be one row in database for each status that a planet has. I could have stored all statuses in a list and store that in database, effectively having one row for any planet. Now there’s one row for any planet + status combination. Choice wasn’t really based on any deep analysis, but merely a gut feeling that this feels like a good idea.
PlanetStatus json
planetId PlanetId
status PlanetaryStatus
expiration Int Maybe
deriving Show Read Eqexpiration column doesn’t have NOT NULL constraint like all other columns in the table. This is reflected in PlanetStatus record where data type of planetStatusExpiration is Maybe Int instead of Int. So some statuses will have expiration time, while others might not. I originally chose to represent time as Int instead of own data type, but I have been recently wondering if that was really a good decision.
Code that does actual database query looks pretty scary on a first glance and it’s rather long. First part of the code is there to query database and join several tables into the query. Second part of the code deals with counting and grouping data and eventually returning [Entity Planet] data that contains all planets that match the criteria.
-- | Load planets that are kragii attack candidates
kragiiTargetPlanets :: (MonadIO m, BackendCompatible SqlBackend backend
, PersistQueryRead backend, PersistUniqueRead backend) =>
Int -> Int -> Key Faction -> ReaderT backend m [Entity Planet]
kragiiTargetPlanets pop farms fId = do
planets <- E.select $
E.from $ (planet `E.LeftOuterJoin` population `E.LeftOuterJoin` building `E.LeftOuterJoin` status) -> do
E.on (status E.?. PlanetStatusPlanetId E.==. E.just (planet E.^. PlanetId)
E.&&. status E.?. PlanetStatusStatus E.==. E.val (Just KragiiAttack))
E.on (building E.?. BuildingPlanetId E.==. E.just (planet E.^. PlanetId))
E.on (population E.?. PlanetPopulationPlanetId E.==. E.just (planet E.^. PlanetId))
E.where_ (planet E.^. PlanetOwnerId E.==. E.val (Just fId)
E.&&. building E.?. BuildingType E.==. E.val (Just Farm)
E.&&. E.isNothing (status E.?. PlanetStatusStatus))
E.orderBy [ E.asc (planet E.^. PlanetId) ]
return (planet, population, building)
let grouped = groupBy ((a, _, _) (b, _, _) -> entityKey a == entityKey b) planets
let counted = catMaybes $ fmap farmAndPopCount grouped
let filtered = filter ((_, p, f) ->
p >= pop
|| f >= farms) counted
let mapped = fmap ((ent, _, _) -> ent) filtered
return mappedIn any case, when we’re querying for possible kragii attack candidates, the query selects all planets that are owned by a given faction and have population of at least 10 (left outer join to planet_population table), have at least 5 farming complex (left outer join to building table) and don’t have on going kragii attack (left outer join to planet_status table). This is encapsulated in kragiiTargetPlanets 10 5 function in the kragiiAttack function shown below.
Rest of the code deals with selecting a random planet from candidates, inserting a new planet_status row to record that kragii are attacking the planet and creating special event so player is informed about the situation and can react accordingly.
kragiiAttack date faction = do
planets <- kragiiTargetPlanets 10 5 $ entityKey faction
if length planets == 0
then return Nothing
else do
n <- liftIO $ randomRIO (0, length planets - 1)
let planet = maybeGet n planets
let statusRec = PlanetStatus <$> fmap entityKey planet
<*> Just KragiiAttack
<*> Just Nothing
_ <- mapM insert statusRec
starSystem <- mapM (getEntity . planetStarSystemId . entityVal) planet
let event = join $ kragiiWormsEvent <$> planet <*> join starSystem <*> Just date
mapM insert eventSecond piece to the puzzle is status removal. In can happen manually or automatically when the prerecorded date has passed. Former method is useful for special events and latter for kind of seasonal things (good harvest for example).
For example, in case of removing kragii attack status, code below serves as an example. The interesting part is deleteWhere that does actual database activity and removes all KragiiAttack statuses from given planet.
removeNews event odds = MaybeT $ do
res <- liftIO $ roll odds
case res of
Success -> do
_ <- lift $ deleteWhere [ PlanetStatusPlanetId ==. kragiiWormsPlanetId event
, PlanetStatusStatus ==. KragiiAttack
]
_ <- tell [ WormsRemoved ]
return $ Just RemoveOriginalEvent
Failure -> do
_ <- tell [ WormsStillPresent ]
return $ Just KeepOriginalEventRemoval of expired statuses is done based on the date, by using <=. operator to compare expiration column to given date.
_ <- deleteWhere [ PlanetStatusExpiration <=. Just date]Like mentioned before, planet statuses can be used for variety of things. One such application is recording particularly good (or poor) harvest season. When such thing occurs, new planet_status record is inserted into database with expiration to set some suitable point in future. System will then automatically remove the status after that date is reached.
In the meantime, every time food production is calculated, we have to check for possible statuses that might affect it and take them into account (as form of small bonus or malus).
While this system is for planet statuses only, similar systems can be build for other uses (like statuses that affect a single ship or whole star system).
Easiest way to catch me nowadays is either via email or on fediverse where I’m tuturto@mastodon.social
DjVu is a digital document format with advanced compression technology. DjVu allows for the distribution of very high resolution images of scanned documents, digital documents, and photographs. DjVu viewers are available for the web browser (search for djvujs in Firefox for an extension), the desktop ( Evince, Okular an BSD/Linux, and djview on BSD/Linux/Windows/Mac), and mobile devices.
The toolchain for encoding and decoding DjVu is djvulibre
djvu.js is a Javascript library useful for online viewing.
djvu.org contains sample documents and specification documents.
The tool you use to convert something to the .djvu format depends on your requirements. If you're converting a basic, black-and-white document, then cjb2 (part of the djvulibre distribution) works:
$ cjb2 -dpi 300 foo.tiff
$ ls
foo.tiff
foo.djvu
If you want to convert something more complex, then use c44 (also a part of the djvulibre distribution):
$ c44 -dpi 300 bar.jpg bar.djvu
$ ls
bar.jpg
bar.djvu
To put both of these files in a single DjVu container:
$ djvm -c baz.djvu foo.djvu bar.djvu
$ ls
bar.djvu
baz.djvu
foo.djvu
You can add bookmarks, too.
Open a text file called book.marks (or any name you prefer) and enter:
(bookmarks
("Foo" "#1")
("Bar" "#2")
)
And then apply it to your DjVu file:
$ djvused -e 'set-outline book.marks' -s baz.djvu
There's more you can do with DjVu, but this has been an overview of how I use it.
The old way:
$ ls /dev/sd*
Another old way:
$ fdisk --list
An old way to see what you just plugged in:
$ sudo dmesg | tail
Some new tricks:
$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 2.7T 0 disk
├─sda1 8:1 0 23.3G 0 part
└─sda2 8:2 0 2.7T 0 part
sdb 8:16 0 3.9G 0 disk
sdc 8:32 0 111.8G 0 disk
├─sdc1 8:33 0 100M 0 part /boot/efi
└─sdc2 8:34 0 111.7G 0 part /
sdd 8:48 0 1.8T 0 disk
├─sdd1 8:49 0 120G 0 part /var
├─sdd2 8:50 0 120G 0 part /tmp
├─sdd3 8:51 0 60G 0 part /opt
└─sdd4 8:52 0 1.5T 0 part /home
sde 8:64 0 298.1G 0 disk
├─sde1 8:65 0 500M 0 part
├─sde2 8:66 0 296.8G 0 part
└─sde3 8:67 0 826M 0 part
sdf 8:80 0 931.5G 0 disk
└─sdf1 8:81 0 931.5G 0 part
sdg 8:96 1 7.5G 0 disk
└─sdg1 8:97 1 7.5G 0 part
User-friendly udisks:
$ udisks --monitor /dev
Ctrl-c
$ udisk --enumerate | sort
/org/freedesktop/UDisks/devices/sda
/org/freedesktop/UDisks/devices/sda1
/org/freedesktop/UDisks/devices/sda2
/org/freedesktop/UDisks/devices/sdb
/org/freedesktop/UDisks/devices/sdc
/org/freedesktop/UDisks/devices/sdc1
[...]
$ udisks --mount /dev/sdc1
Mounted /dev/sdc1 on /media/mythumbdrive
$ udisks --unmount /dev/sdc1
Hosted by Ahuka on 2019-03-08 is flagged as Clean and released under a CC-BY-SA license.
Tags: YouTube, Channels, Subscriptions.
Listen in ogg, spx, or mp3 format.
Series: YouTube Subscriptions | Comments (0)
I am subscribed to a number of YouTube channels, and I am sharing them with you
Here is a bash script to generate an org-mode word list matrix.
It requires at least one file ending in .list to be used as a source of words or strings.
#!/bin/bash
if [ -z $1 ]; then
DEST=matrix.org
else
DEST=$1
fi
cat >> "${DEST}" <<EOF
| | a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z | ? |
|-+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|
EOF
VERT=(a b c d e f g h i j k l m n o p q r s t u v w x y z ?)
cat *list > tmp || exit
BIG=`wc -l tmp | cut -f1 -d' '`
c="0"
while [ "$c" -lt "27" ]; do
# horizontal row across
n="0"
v=`echo ${VERT[$c]}`
printf "| $v |" >> "${DEST}"
while [ "$n" -lt "27" ]; do
i=`echo $((1 + RANDOM % $BIG))`
w=`awk "FNR==$i" tmp`
#reduce chance of empty cell
if [[ -z $w ]]; then
i=`echo $((1 + RANDOM % $BIG))`
w=`awk "FNR==$i" tmp`
echo "blank cell found"
fi
printf "$w | " >> "${DEST}"
n=$[$n+1]
done
echo " " >> "${DEST}"
c=$[$c+1]
done
/usr/bin/rm tmp
When you open the resulting file (matrix.org by default) in emacs, use the fill-paragraph (m-x fill-paragraph) function to align the cells into a pretty table.
Invent your own key, and generate some test passwords. Do this 6 or 8 times, and then try to reverse the key using the passwords and the table. If the logic to reverse the key is too simple, then try using values relying on the metadata, rather than data, of the table (for instance, the number of letters in the first word in the table starting with the same letter as the site name, or whatever).
Do you have analogue methods of generating passwords? Post ideas to either the comments or, better yet, as an HPR episode!
Here is a word list for testing:
http://hackerpublicradio.org/eps/hpr2764_wordlist.html
Klaatu reads a phlog (gopher) post by Deepgeek explaining the practical uses of SPF records.
Get a full list of all our shows.