In the two previous episodes we built a weighted list and used that to build markov chains. This time we’re going to use them to generate some names based on examples. I’m skipping over a lot of uninteresting code in this episode, concentrating only the parts that deal with names.

Idea

Person in game might hear scurrying sounds inside walls of their quarters. Then they have option of getting a cat, taming a rat or letting someone else deal with the problem. Depending on their choice, they might end up with a cat or a rat, that of course needs a name. Game offers 3 different options of names that haven’t been used before and person can always opt for completely random one.

Config

While we’re not going to dig very deep into making configurations for markov chains, we can have look at the overall process.

We have list of names to serve as examples and three functions, which implementation I won’t delve into:

• start for adding starting element
• links for recording link between two elements
• end adds ending element

addName function is used to add single name into config:

addName :: Int -> Text -> Config Text -> Config Text
addName n s config =
    links pairs $
            end elements $
            start elements config
    where
        elements = chunksOf n s
        pairs = zip elements (safeTail elements)

First s (name) is split into strings of length n. These elements are then combined into pairs, where consecutive elements form a pair. Final step is to add start and ending elements into config, followed by links between elements of pairs.

We can then fold a list of examples into config:

nameConfig :: [Text] -> Int -> Config Text
nameConfig xs n =
    foldr (addName n) emptyConfig xs

This starts with emptyConfig and calls addName repeatedly until all elements of list containing examples have been processed.

Implementation

Now that we have configuration, we can start generating names. As usual, I like to keep things specific and generate PetName instead of just Text. I happened to have list of ancient greek names at hand, so I used that. Later on we’ll have to add more cultures, like Romans, Parthians, Persians, Germans, Phoenicians and so on.

General implementation of generating infinite list of strings of specific kind is shown below:

names :: (RandomGen g, Eq b) => (Text -> b) -> Config Text -> g -> [b]
names t config g =
    nub $ (t . toTitle . concat) <$> chains config g

It’s easier to read if you start from right. chains config g generates infinite list of markov chains with given configuration. Next we create a new function (t . toTitle . concat), which uses concat to combine list of Text into single Text, toTitle to capitalize is correctly and t to transform it to something (PetName in our case). <$> is then used to apply this function to each element of our infinite list. Finally nub is used to remove duplicate entries.

With names we can then define petNames:

petNames :: (RandomGen g) => g -> [PetName]
petNames =
    names MkPetName greekNameConfig

MkPetName is value constructor that turns Text into PetName (this is t used by names function).

Pets

Pets are currently very much work in progress. They have few attributes and there can be two different kinds of pets:

Pet json
    name PetName
    type PetType
    dateOfBirth StarDate
    dateOfDeath StarDate Maybe
    ownerId PersonId
    deriving Show Read Eq

data PetType
    = Cat
    | Rat
    deriving (Show, Read, Eq, Ord, Enum, Bounded)

The actual beef is namingPetEvent function. When applied with Entity Person, Entity Pet and StarDate, it will create News that can be saved into database and later on showed to player. While the code is shown below, I’m not going to go over it line by line:

namingPetEvent :: (PersistQueryRead backend, MonadIO m,
    BaseBackend backend ~ SqlBackend) =>
    Entity Person -> Entity Pet -> StarDate -> ReaderT backend m News
namingPetEvent personE petE date = do
    pets <- selectList [ PetOwnerId ==. (entityKey personE)
                       , PetDateOfDeath ==. Nothing
                       ] []
    let names = (petName . entityVal) <$> pets
    g <- liftIO getStdGen
    let availableNames = take 3 $ filter (\x -> not (x `elem` names)) $ petNames g
    let content = NamingPet (NamingPetEvent { namingPetEventPersonId = entityKey personE
                                            , namingPetEventPetId = entityKey petE
                                            , namingPetEventPetType = (petType . entityVal) petE
                                            , namingPetEventDate = date
                                            , namingPetNameOptions = availableNames
                                            })
                            [] Nothing
    return $ mkPersonalSpecialNews date (entityKey personE) content

General idea is to use selectList to load living pets of given person and then extract their names. With random generator g, we create a infinite list of PetNames, remove already used names from it and take 3 first ones. These names are then used to create NamingPetEvent.

In closing

Names are probably one of the most common applications of markov chains in games. Same technique can be used to generate nonsense books and articles that look realistic on a glance.

Questions, comments and feedback is welcomed, best way to reach is email or in fediverse where I’m tuturto@mastodon.social. Or even better, record your own episode for Hacker Public Radio.

ad astra!

https://archive.org/details/HisGirlFriday-1940

Boy, I wish I’d found this one first!

New hosts

Welcome to our new host:
Carl.

Last Month's Shows

Comments this month

These are comments which have been made during the past month, either to shows released during the month or to past shows. There are 14 comments in total.

Past shows

There are 7 comments on 5 previous shows:

• hpr2895 (2019-09-06) "The work of fire fighters, part 2" by Jeroen Baten.
• • Comment 3: Don on 2019-10-20: "great podcast"
  
  
• hpr2900 (2019-09-13) "Better Social Media 01 - Introduction" by Ahuka.
• • Comment 1: Jeroen baten on 2019-10-05: "Hope you will find time to discuss Okuna"
  • Comment 2: Kevin O'Brien on 2019-10-05: "No plans for now"
  
  
• hpr2906 (2019-09-23) "Feature Engineering for Data-Driven Decision Making" by b-yeezi.
• • Comment 2: Gabriel Evenfire on 2019-10-08: "Love the idea here..."
  
  
• hpr2909 (2019-09-26) "ONICS Basics Part 3: Networking Fundamentals" by Gabriel Evenfire.
• • Comment 2: Gabriel Evenfire on 2019-10-08: "Thanks for the feedback"
  • Comment 3: gerryk on 2019-10-17: "Yet another top episode"
  
  
• hpr2911 (2019-09-30) "my internet connection" by Jezra.
• • Comment 1: Beeza on 2019-10-05: "HPR 2911"
  
  

This month's shows

There are 7 comments on 5 of this month's shows:

• hpr2913 (2019-10-02) "Windows, SDN, and Firewalls" by Beto.
• • Comment 1: ClaudioM on 2019-10-02: "+1 on Chocolatey Recommendation"
  
  
• hpr2915 (2019-10-04) "Intro - My Recording Setup" by Carl.
• • Comment 1: Ken Fallon on 2019-10-04: "More shows on ...."
  
  
• hpr2921 (2019-10-14) "Geocaching with the family" by thelovebug.
• • Comment 1: jezra on 2019-10-17: "what a fun adventure"
  • Comment 2: Kevin O'Brien on 2019-10-17: "I loved the show"
  
  
• hpr2925 (2019-10-18) "LinuxLugCast's Memorial for FiftyOneFifty " by Honkeymagoo.
• • Comment 1: lostnbronx on 2019-10-19: "I Never Met Fifty, But I Knew Him"
  
  
• hpr2928 (2019-10-23) "Building markov chains with Haskell" by tuturto.
• • Comment 1: b-yeezi on 2019-10-29: "Thanks for this episode"
  • Comment 2: tuturto on 2019-10-31: "thanks for the feedback!"
  
  

Mailing List discussions

Policy decisions surrounding HPR are taken by the community as a whole. This discussion takes place on the Mail List which is open to all HPR listeners and contributors. The discussions are open and available on the HPR server under Mailman.

The threaded discussions this month can be found here:

Events Calendar

With the kind permission of LWN.net we are linking to The LWN.net Community Calendar.

Quoting the site:

This is the LWN.net community event calendar, where we track events of interest to people using and developing Linux and free software. Clicking on individual events will take you to the appropriate web page.

Any other business

FLOSS Weekly

Ken Fallon and Ahuka appeared on FLOSS Weekly Episode 553 on October 30^th 2019 to talk about Hacker Public Radio.

OggCamp 2019

There was an HPR presence at OggCamp 2019. This was held at The Manchester Conference Centre during the weekend of October 19^th and 20^th 2019. We had an HPR table, which was manned by many HPR hosts and received many visitors. Ken recorded interviews which will be released later in November.

FOSDEM 2020

A request has been made to get a Podcasters table at FOSDEM 2020.

HPR on podcast networks

We need some help getting HPR on Google Podcasts, Stitcher, Soundcloud, etc.

Ken versus espeak

Which is preferable, the espeak show summary or Ken’s new reading of the information?

Watching Star Wars for the first time

A question: should it be watched in Episode or Production Order?

Tags and Summaries

There were no tag or summary updates in the past month.

If you would like to contribute to the tag/summary project visit the summary page at https://hackerpublicradio.org/report_missing_tags.php and follow the instructions there.

Talking about large water system, breathing gear, “the walk”, flash-over and back-draft.

// prove you are not running some process

$ pidof tcsh
// nothing

$ sudo pidof tcsh
// nothing

// launch tcsh in a new namespace with unshare:

$ sudo unshare --fork --pid --mount-proc tcsh

// from within that session:

# pidof tcsh
1

// wait what??
// yes tcsh is the first pid of its own namespace

// from another term
$ ps 1
init

$ pidof tcsh
26814

// from inside the namespace, pid is seen as 1
// from outside, pid is normal

$ ps tree | less
// search for tcsh

// See evidence of namespaces:

$ ls /proc/*/ns

$ ls /proc/26814/ns
ipc net pid user uts [...]

To see this in action for a slightly more pragmatic purpose, you can use the lxc command. The LXC system uses namespaces and cgroups to create functional containers that act, more or less, like a Virtual Machine, except that they are built in containers so that they do not have to emulate hardware.

If your system doesn't have LXC installed, first install it:

$ sudo dnf install lxc lxc-templates lxc-doc

// on Ubuntu or Debian:

$ apt install lxc

You also need to create a network bridge so that your container and your host system (that's the computer you're sitting in front of right now) can communicate.

$ sudo ip link add br0 type bridge
$ sudo ip addr show br0
7: br0: <BROADCAST,MULTICAST> mtu 1500 qdisc
   noop state DOWN group default qlen 1000
   link/ether 26:fa:21:5f:cf:99 brd ff:ff:ff:ff:ff:ff

Now give your bridge device an IP address that doesn't conflict with any existing IP address on your network:

$ sudo ip addr add 192.168.168.168 dev br0
$ sudo ip link set br0 up

Create a configuration for your container. You can base this on the samples provided by lxc (located in /usr/share/docs/lxc or similar). Everything but veth, br0, and up is arbitrary. You can make up all the values.

lxc.utsname = hackerpublicradio
lxc.network.type = veth
lxc.network.flags = up
lxc.network.link = br0
lxc.network.hwaddr = 4a:49:43:49:79:bd
lxc.network.ipv4 = 192.168.168.1/24
lxc.network.ipv6 = 2003:db8:1:0:214:c0ff:ee0b:3596

Now install an OS into your container. OS templates are provided by LXC in /usr/share/doc/lxc/templates or a similar location.

$ ls -m /usr/share/lxc/templates/
lxc-alpine, lxc-altlinux, lxc-archlinux, lxc-busybox, lxc-centos [...]

Choose a template and install. I use Alpine in the recorded show, because it's supposed to be really small. I don't necessarily recommend Alpine. I recommend Slackware, of course.

$ sudo lxc-create --name slackware --template slackware

Once the install is done, start your container:

$ sudo lxc-start --name slackware
--rcfile ~/mycontainer.conf

Now attach to the container:

$ sudo lxc-attach --name slackware
#

Run a command.

# uname -av
Linux hackerpublicradio 5.3.0.x86_64 #1 SMP Wed Oct 10 18:34:01 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux

This is the technology that Docker and OCI projects use to create containers. And when a bunch of containers start swarming around on a bunch of hosts, you eventually end up with a cloud. How do you manage all of these things? That will be the topic for the next entry in this series, I'll bet.

In this episode I cover my use of global variables.

List of global variables along with associated comments explaining what they are used for

# GLOBAL VARIABLES

RemoteDevice = "pi@192.168.1.13"
# Username and ip address of the remote device to control

SeekMin = -6
# Sets the minimum value of the variable SeekPosition

SeekMax = 6
# Sets the maximum value of the variable SeekPosition

SeekPosition = 0
# stores seek menu position,

SeekMenu = False
# used to track seek menu state, ie are we in seek menu or not

FirstPass = True
# Used to track 1st time button 5 (backlight toggle) is pushed, turns off blinkstick

LcdLightOn = False
# used to track toggle sate of backlight button 5

MenuMin = 0
# Sets the minimum value of variable "Menu"

MenuMax = 2
# Sets the maximum value of variable "Menu"

Menu = 0
# global variable used to keep trak of selected menu

IrActive = False
# used to track toggle state of active infrared buttons, when false disables
# all buttons on the remote control except the blue button.

StoredTime = 0
# Stores curent time in seconds when a button is pushed, used by double button tap feature

#GET_IP_CMD = "hostname –all-ip-addresses"
# Debian 7 wheezy, Command to get IP adress

GET_IP_CMD = "hostname --all-ip-addresses | cut -d' ' -f1"
# Debian 8 jessie, Command to get IP adress

#GET_ESSID_CMD = "iwconfig wlan0 | grep 'ESSID:' | cut -d':' -f2"
# Debian 7 wheezy, Command to get wifi ESSID

GET_ESSID_CMD = "/sbin/iwconfig wlan0 | grep 'ESSID:' | cut -d':' -f2"
# Debian 8 wheezy, Command to get wifi ESSID

GET_WIFI_STRENGTH_CMD = "/sbin/iwconfig wlan0 | grep 'Link Quality=' | awk '{ print $2 }'"
# Command to get wifi signal strength