Site Map - skip to main content - dyslexic font - mobile - text - print

Hacker Public Radio

Your ideas, projects, opinions - podcasted.

New episodes Monday through Friday.



Welcome to HPR the Community Podcast Network

We started producing shows as Today with a Techie on 2005-09-19, 13 years, 5 months, 10 days ago. Our shows are produced by listeners like you and can be on any topic that "are of interest to Hackers". If you listen to HPR then please consider contributing one show a year. If you record your show now it could be released in 17 days.

Meet the team

Please help out tagging older shows !


Latest Shows


hpr2755 :: My YouTube Subscriptions #2

Part two of my list of subscribed channels


Hosted by Ahuka on 2019-02-22 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


hpr2754 :: Craigslist Scam Catch

Helped a client avoid being scammed on Craigslist and wanted to share some tips to HPR.

Hosted by Edward Miro / c1ph0r on 2019-02-21 is flagged as Explicit and released under a CC-BY-SA license.
Tags: craigslist, scam, con, social-engineering, puppy, dog, money, moneygram, infosec, cyber-security 101.
Listen in ogg, spx, or mp3 format. Series: Privacy and Security | Comments (0)

Introduction

Hello and welcome to Hacker Public Radio, I’m Edward Miro and for this episode I decided to record on a personal experience I had recently helping a client catch a Craigslist Scam. This will be part two in my series I’m calling “Information Security for Everyone”. As with most of the content I publish in the world of INFOSEC, my goal is to present the information in a way that a majority of people can get value from and anyone can play this for a friend, colleague or family member and make it easy for the non-hackers in our lives to understand. This particular episode shows a powerful way social-engineering can be implemented to steal money from unsuspecting victims and I will break down a few main points and red flags to look out for at the end.

A couple weeks ago I was sitting with a client when she asked me offhandedly if I’d ever sent a Moneygram before. I told her I had and ask curiously why she wanted to know. She explained that she was very excited to be adopting a puppy from online and she needed to send $350 USD to the service that ships pets across the country. This immediately caused my hacker-sense to start tingling so I probed a bit more about the transaction.

I asked if she had spoken to the seller on the phone, and she said she hadn’t. I said that seemed weird, but she assured me that the seller said it had to do with her religion. I wasn’t aware of any religious prohibitions to speaking on the phone that also allowed using Craigslist, but okay. I told her that that seemed a bit fishy to me. She asserted that she thought it did too at first, but she knew it was legit because she wasn’t sending the money to the seller, it was being sent to a third party pet transportation company that the seller had had contact her. She even showed the website of the company on her cell phone, which to be blunt, to my eyes looked extremely janky. I asked her if we could sit down for a few minutes and take a look at a few details before she sends anyone any money. She reluctantly agreed and really wanted this puppy.

The first thing I asked to look at was the emails back and forth from the seller. I checked Google and all other major social media sites for the sellers name. No matches. Couldn’t Google the sellers email address due to the Craigslist email relay system. This in and of itself might be okay, we all use pseudonyms online sometimes and Craigslist is a site you might not wanna use your real name. Fine.

She then showed me the email thread with the shipping company.

The first strange thing I noticed from the emails was the link to the pet shipping company. The name didn’t match the URL in the link. You’d think a business would be able to get their own name right. I also saw that if you Googled the name given by the shipper, it’s extremely similar to a legitimate pet shipping company and indeed that legit company comes up as the first site found due to Google “fixing” our query. When you go to the link in the email however, the site itself was terrible to my eyes, but not to my client who is not as seasoned as I am at catching scams. I also showed her that the “company” didn’t have any social media presence. At all. No Facebook, Twitter, anything. Also the email address that was contacting her was reallylongcompanyname@outlook.com

She also told me she had spoken to the shippers on the phone and I asked if she still had their number. She did, but she told me she couldn’t ever get through when she called them and they’d always have to call her back. I asked for the number and called it on my phone. It was a Google Voice number! Not only that it was set to screening mode. She also told me when he did call her, he was rude and tried to get her to hurry up and send the money. I told her I was 100% confident this was a scam and I advised her to not go through with the deal.

At this point she was extremely unhappy, but felt it was still a legitimate transaction because she had pictures sent to her of not only the puppy, but of the puppy in the shipping crate at the shipping company waiting for payment to be shipped. She explained that it’s not like it was a person trying to sell dogs or from a puppy mill. It was a lady giving it away for free and the money was for was the shipping. She just didn’t see why a scammer would go to the trouble of doing that and felt the pictures were authentic. I asked her to save all the images to her device and then showed her a site she could use to do reverse image searches. Before she did it, I asked her if she agreed that if this wasn’t a scam those pictures wouldn’t exist anywhere on the internet. She agreed and each of the pictures was found at least 9 other places online. Her heart sank and she didn’t have any further rebuttals to my concerns. She knew it was a scam and I just saved her from losing at least $350 USD. Not to mention that the scammer would have also asked for more money later for “shots” and “insurance”. Who knows how far they might have gotten.

So here are the main red flags:

  • Seller wouldn’t talk on phone
  • Seller name didn’t seem legitimate
  • Name of shipping company didn’t match URL in email
  • Googling company name shows close match with legitimate company
  • Company website very poorly designed and implemented
  • Company has no social media presence
  • Email address of contact at company using generic email address and not a legit domain
  • Contact at company could only call her and she was never able to make inbound calls
  • Phone number of company was Google Voice number
  • Reverse image searches showed “proof” photos unoriginal

A few of the tricks used by the scammers in this scam to make it more successful:

  • Listed as adoption versus a sale to alleviate concern
  • Handed off to “second party” to build legitimacy
  • Use cute puppy pictures to appeal to emotion and overrule suspicion
  • Counted on target not paying attention to detail
  • Shipper established a sense of urgency

She was very thankful and I told her to be very careful when anyone from online ever asks her to send money. I told her in all likelihood this was probably one person the whole time, hence why the person adopting out the dog “couldn’t talk on the phone”. They were also probably not even in this country as we know many of these scams aren’t. She did say that the shippers English wasn’t good. I also told her to make she shares this experience with all her friends and family. I always feel the best way to handle someone getting caught in a scam is to be on their side and never shame them. We are all susceptible to scams and social engineering and the best way to proceed is to empower them to share what they’ve learned. I also sent her a link to an article on the BBB site about these very types of scams that I’ll also link below. She was shocked how similar her experience was to the ones explained on the article.

Well, thank you for taking the time to listen to my experience helping a client avoid getting caught in the all too common Craigslist scam. I hope this will help any non-hackers in your life and like I say in all my podcasts, I don’t claim to know all there is to know and love feedback and any opportunities to learn more or collaborate with others in the field. As with most of the research and articles I’ve written in the past, these are geared toward standard users in a business setting and are meant to be a jumping off point for further research and to be a foundation for cyber security 101 level training classes. If you like what I do, and want to have me come speak to your team, or just wanna chat, feel free to email me.

Thank you and have a great day!

https://www.bbb.org/article/investigations/14214-puppy-scams-how-fake-online-pet-sellers-steal-from-unsuspecting-pet-buyers-a-bbb-study

https://www.rover.com/blog/internet-dog-puppy-scams/


hpr2753 :: Specific Settings In Storytelling

Lostnbronx looks at why you might choose specific settings for your tales.

Hosted by lostnbronx on 2019-02-20 is flagged as Clean and released under a CC-BY-SA license.
Tags: stories, storytelling, setting, lostnbronx.
Listen in ogg, spx, or mp3 format. Series: Random Elements of Storytelling | Comments (0)

How does setting interact with plot or character? Why would you choose one type of setting over another? And how do certain specific settings become intrinsic aspects of the story itself?

Lostnbronx takes a breezy, mostly incoherent stab at this rather complicated topic.


hpr2752 :: XSV for fast CSV manipulations - Part 2

Part 2 of my introduction to the XSV tool


Hosted by b-yeezi on 2019-02-19 is flagged as Clean and released under a CC-BY-SA license.
Tags: csv,commandline,data.
Listen in ogg, spx, or mp3 format. Comments (0)

XSV for fast CSV manipulations - Part 1: Basic Usage

https://github.com/BurntSushi/xsv

Introduction

xsv is a command line program for indexing, slicing, analyzing, splitting and joining CSV files. Commands should be simple, fast and composable:

  1. Simple tasks should be easy.
  2. Performance trade offs should be exposed in the CLI interface.
  3. Composition should not come at the expense of performance.

We will be using the CSV file provided in the documentation.

Commands covered in this episode

  • fixedlengths - Force a CSV file to have same-length records by either padding or truncating them.
  • fmt - Reformat CSV data with different delimiters, record terminators or quoting rules. (Supports ASCII delimited data.)
  • input - Read CSV data with exotic quoting/escaping rules.
  • partition - Partition CSV data based on a column value.
  • split - Split one CSV file into many CSV files of N chunks.
  • sample - Randomly draw rows from CSV data using reservoir sampling (i.e., use memory proportional to the size of the sample).
  • cat - Concatenate CSV files by row or by column.

hpr2751 :: Battling with English - part 3

Misunderstandings about English grammar, spelling, punctuation, etc.


Hosted by Dave Morriss on 2019-02-18 is flagged as Explicit and released under a CC-BY-SA license.
Tags: grammar,spelling,punctuation,word misuse,English.
Listen in ogg, spx, or mp3 format. Comments (0)

Battling with English - part 3

Some word confusions

In this episode, the third of this series, I’m looking at some words that are sometimes used in the wrong places, often being confused one with another. These words are often particularly difficult to differentiate by people for whom English is not their first language.

Long notes

As usual I have provided detailed notes and examples for this episode, and these can be viewed here.


hpr2750 :: Windmill is on the Fritz

Using Fritzing to help reverse engineer a circuit in a winter model village windmill


Hosted by Ken Fallon on 2019-02-15 is flagged as Clean and released under a CC-BY-SA license.
Tags: Fritzing, Reverse Engineering, LED.
Listen in ogg, spx, or mp3 format. Series: Hobby Electronics | Comments (0)

In this episode Ken uses Fritzing tool to keep track of how a winter model village windmill is wired together. Leading to identifying the problem component.

Fritzing is an open-source initiative to develop amateur or hobby CAD software for the design of electronics hardware, to support designers and artists ready to move from experimenting with a prototype to building a more permanent circuit. It was developed at the University of Applied Sciences of Potsdam.
From https://en.wikipedia.org/wiki/Fritzing


hpr2749 :: Lostnbronx and Klaatu commentary from episode 2743

Thoughts about RPG character building, modern RPG play style compared to the Old School, and more

Hosted by klaatu on 2019-02-14 is flagged as Clean and released under a CC-BY-SA license.
Tags: rpg, game, gaming.
Listen in ogg, spx, or mp3 format. Comments (0)

Out-takes from episode 2743. This is commentary about modern RPG play style, the character build process, Starfinder as a system, and more.

Did you know that Lostnbronx and Klaatu have a gaming blog? We do! You should go subscribe to it at mixedsignals.ml

The blog features commentary about gaming, tech, geek culture, a podcast or two, and lots more.


hpr2748 :: Writing Web Game in Haskell - Special events

tuturto walks through implementation of special events in web based game

Hosted by tuturto on 2019-02-13 is flagged as Clean and released under a CC-BY-SA license.
Tags: haskell, yesod.
Listen in ogg, spx, or mp3 format. Comments (0)

Intro

I was tasked to write kragii worms in the game and informed that they’re small (10cm / 4 inches) long worms that burrow in ground and are drawn to farming fields and people. They’re dangerous and might eat harvest or people.

Special events build on top of the new system I explained in episode 2733. They are read from same API as regular news and need same ToJSON, FromJSON, ToDto and FromDto instances as regular news (for translating them data transfer objects and then into JSON for sending to client).

Loading

Starting from the API interface, the first real difference is when JSON stored into database is turned into NewsArticle. Two cases, where special news have available options added to them and regular news are left unchanged. These options tell player what choices they have when dealing with the situation and evaluated every time special event is loaded, because situation might have changed since special event got stored into database and available options might have changed.

addOptions (key, article) = case article of
                                Special news ->
                                    (key, Special $ availableOptions news)
                                _ ->
                                    (key, article)

availableOptions :: SpecialNews -> SpecialNews
availableOptions x =
    case x of
        KragiiWorms event _ choice ->
            KragiiWorms event (eventOptions event) choice

eventOptions is one of the events defined in SpecialEvent type class that specifies two functions every special event has to have. eventOptions lists what options the event has currently available and resolveEvent resolves the event according to choice user might have made (hence Maybe in it).

Type class is parametrized with three types (imaginatively named to a, b and c). First is data type that holds information about special event (where it’s happening and to who for example), second one is one that tells all possible choices player has and third one lists various results that might occur when resolving the event. In this example they’re KragiiWormsEvent, KragiiWormsChoice and KragiiResults.

data KragiiWormsEvent = KragiiWormsEvent
    { kragiiWormsPlanetId   :: Key Planet
    , kragiiWormsPlanetName :: Text
    , kragiiWormsSystemId   :: Key StarSystem
    , kragiiWormsSystemName :: Text
    , kragiiWormsDate       :: Int
    }

data KragiiWormsChoice =
    EvadeWorms
    | AttackWorms
    | TameWorms

data KragiiResults =
    WormsStillPresent
    | WormsRemoved
    | WormsTamed
    | CropsDestroyed (RawResource Biological)
    | FarmersInjured

Definition of the SpecialEvent type class is shown below. Type signature of resolveEvent is gnarly because it’s reading and writing database.

class SpecialEvent a b c | a -> b, a -> c where
    eventOptions :: a -> [UserOption b]
    resolveEvent :: ( PersistQueryRead backend, PersistQueryWrite backend
                    , MonadIO m, BaseBackend backend ~ SqlBackend ) =>
                    (Key News, a) -> Maybe b -> ReaderT backend m (Maybe EventRemoval, [c])

One more piece we need is UserOption. This records options in a format that is useful in the client side. Each option player has are given title and explanation that are shown on UI.

data UserOption a =
    UserOption { userOptionTitle :: Text
               , userOptionExplanation :: [Text]
               , userOptionChoice :: a
               }

Current implementation of eventOptions doesn’t allow database access, but I’m planning on adding that at the point where I need it. Example doesn’t show all different options, as they all have same structure. Only first option in the list is shown:

eventOptions _ = [ UserOption { userOptionTitle = "Avoid the worms"
                              , userOptionExplanation = [ "Keep using fields, while avoiding the worms and hope they'll eventually leave."
                                                        , "50 units of biologicals lost"
                                                        , "25% chance of worms leaving"
                                                        ]
                              , userOptionChoice = EvadeWorms
                            }
                   , ...
                   ]

Making choice

putApiMessageIdR handles updating news with HTTP PUT messages. First steps is to check that caller has autenticated and retrieve id of their faction. News article that is transferred in body as JSON is parsed and checked for type. Updating regular news articles isn’t supported and is signaled with HTTP 403 status code. One more check to perform is to check that news article being edited actually belong to the faction player is member of. If that’s not the case HTTP 404 message is returned.

If we got this far, news article is updated with the content sent by client (that also contains possible choice made by user). There’s no check that type of news article doesn’t change or that the option selected doesn’t change (I need to add these at later point). In the end, list of all messages is returned back to the client.

putApiMessageIdR :: Key News -> Handler Value
putApiMessageIdR mId = do
    (_, _, fId) <- apiRequireFaction
    msg <- requireJsonBody
    let article = fromDto msg
    _ <- if isSpecialEvent article
            then do
                loadedMessages <- runDB $ selectList [ NewsId ==. mId
                                                     , NewsFactionId ==. fId ] [ Asc NewsDate ]
                if length loadedMessages == 0
                    then apiNotFound
                    else runDB $ update mId [ NewsContent =. (toStrict $ encodeToLazyText article) ]
            else apiForbidden "unsupported article type"
    loadAllMessages fId

Resolving event

Special event occured, user made (or did not) a choice. Now it’s time to simulate what happens. Below is resolveEvent for kragii attack.

resolveEvent keyEventPair (Just choice) =
    runWriterT . runMaybeT $
        case choice of
                EvadeWorms ->
                    chooseToAvoid keyEventPair

                AttackWorms ->
                    chooseToAttack keyEventPair

                TameWorms ->
                    chooseToTame keyEventPair

resolveEvent keyEventPair Nothing =
    runWriterT . runMaybeT $ noChoice keyEventPair

runWriterT and runMaybeT are used as code being called uses monad transformers to add some extra handling. WriterT adds ability to record data (KragiiResult in this case) and MaybeT adds ability to stop computation early if one of the steps return Nothing value.

Let’s walk through what happens when user has chosen to avoid kragii worms and keep working only part of the fields. First step is to load faction information. If faction couldn’t be found, we abort. Next amount of biological matter consumed and how much is left is calculated. Again, if calculation isn’t possible, we’ll abort. This step reaches into database and updates amount of biological matter stored by the faction (again, possibility to stop early). Final step is to check if kragii leave or not (again, chance of abort).

chooseToAvoid :: ( MonadIO m, PersistQueryWrite backend
                 , BaseBackend backend ~ SqlBackend ) =>
                 (Key News, KragiiWormsEvent)
                 -> MaybeT (WriterT [KragiiResults] (ReaderT backend m)) EventRemoval
chooseToAvoid (_, event) = do
    faction <- getFaction event
    (cost, bioLeft) <- calculateNewBio (RawResource 50) (entityVal faction)
    _ <- destroyCrops faction cost bioLeft
    removeNews $ PercentileChance 25

Loading faction has several step. Id is stored in the event is used to load planet. Planet might or might have an owner faction, depending on if it has been settled. This faction id is used to load faction data. Loading might fail if corresponding record has been removed from database and planet might not be settled at the given time. Any of these cases will result Nothing be returned and whole event resolution being aborted. I’m starting to really like that I don’t have to write separate if statements to take care of these special cases.

getFaction :: ( MonadIO m, PersistStoreRead backend
              , BaseBackend backend ~ SqlBackend ) =>
              KragiiWormsEvent
              -> MaybeT (WriterT [KragiiResults] (ReaderT backend m)) (Entity Faction)
getFaction event = MaybeT $ do
    planet <- lift $ get $ kragiiWormsPlanetId event
    let owner = join $ fmap planetOwnerId planet
    res <- lift $ mapM getEntity owner
    return $ join res

Amount of biological matter in store is stored in faction information. If it’s zero or less, Nothing is returned as there’s nothing to do really. In other cases, amount of biological matter left is calculated and result returned in form of ( cost, biological matter left ). I’m carrying around the cost, as it’s later needed for reporting how much matter was removed.

calculateNewBio :: Monad m =>
                RawResource Biological -> Faction
                -> MaybeT (WriterT [KragiiResults] m) ((RawResource Biological), (RawResource Biological))
calculateNewBio cost faction = MaybeT $ do
    let currentBio = factionBiologicals faction
    return $ if currentBio > 0
                then Just $ ( cost
                            , RawResource $ max 0 (currentBio - unRawResource cost))
                else Nothing

destroyCrops updates database with new amount of biological matter in store for the faction and records amount of destruction in CropsDestroyed. tell requires that we have Writer at our disposal and makes recording information nice and easy.

destroyCrops :: ( MonadIO m, PersistQueryWrite backend, BaseBackend backend ~ SqlBackend ) =>
                Entity Faction -> RawResource Biological
                -> RawResource Biological -> MaybeT (WriterT [KragiiResults] (ReaderT backend m)) ()
destroyCrops faction cost bioLeft = MaybeT $ do
    _ <- lift $ updateWhere [ FactionId ==. entityKey faction ]
                            [ FactionBiologicals =. unRawResource bioLeft ]
    tell [ CropsDestroyed cost ]
    return $ Just ()

Final step is to roll a percentile die against given odds and see what happens. In case of Success, we record that worms were removed and value of function will be Just RemoveOriginalEvent. If we didn’t beat the odds, WormsStillPresent gets recorded and value of function is Just KeepOriginalEvent. Return value will then be used later to mark special event handled.

removeNews :: ( PersistStoreWrite backend, MonadIO m, BaseBackend backend ~ SqlBackend ) =>
              PercentileChance -> MaybeT (WriterT [KragiiResults] (ReaderT backend m)) EventRemoval
removeNews odds = MaybeT $ do
res <- liftIO $ roll odds
    case res of
        Success -> do
            _ <- tell [ WormsRemoved ]
            return $ Just RemoveOriginalEvent
        Failure -> do
            _ <- tell [ WormsStillPresent ]
            return $ Just KeepOriginalEvent

So result of this whole matter is:

( [KragiiResults], Maybe EventRemoval )

and whole lot of database activity.

Handling events during simulation

Pieces are now in place, time to put things in motion. When handling special events for a faction, first step is to load all unhandled ones and then call handleSpecialEvent for each of them.

handleFactionEvents :: (BaseBackend backend ~ SqlBackend
                       , PersistStoreWrite backend, PersistQueryRead backend
                       , PersistQueryWrite backend, MonadIO m) =>
                       Time -> Entity Faction -> ReaderT backend m [Key News]
handleFactionEvents date faction = do
    loadedMessages <- selectList [ NewsFactionId ==. (entityKey faction)
                                 , NewsSpecialEvent ==. UnhandledSpecialEvent ] [ Desc NewsDate ]
    let specials = mapMaybe extractSpecialNews $ parseNewsEntities loadedMessages
    mapM (handleSpecialEvent (entityKey faction) date) specials

resolveEvent resolves event based on choice user maybe made (this is what we explored earlier in the episode). Depending on the result of resolveEvent, event gets marked to handled and dismissed. In any case, a news article spelling out what happend is created and saved.

handleSpecialEvent :: (PersistQueryWrite backend, MonadIO m
                      , BaseBackend backend ~ SqlBackend) =>
                      Key Faction -> Time -> (Key News, SpecialNews) -> ReaderT backend m (Key News)
handleSpecialEvent fId date (nId, (KragiiWorms event _ choice)) = do
    (removal, results) <- resolveEvent (nId, event) choice
    _ <- when (removal /= Just KeepOriginalEvent) $
                    updateWhere [ NewsId ==. nId ]
                                [ NewsSpecialEvent =. HandledSpecialEvent
                                , NewsDismissed =. True ]
    insert $ report fId date event choice results

Result article creation is abstracted by ResultReport type class. It has single function report that takes parameters: database key of the faction the event concerns of, current time, special event that was processed, choice that was made and list of records telling what happened during resolution. It will return News that is ready to be saved into database.

class ResultsReport a b c | a -> b, a -> c where
report :: Key Faction -> Time -> a -> Maybe b -> [c] -> News
  • quite long and verbose instance
  • essentially take event, choice and results and build a string explaining what actually happened
  • <> is monoid operation for combining things, here used for text

Instance declaration is pretty long, because there’s many different cases to account for and by definition they’re all pretty verbose. I have included it in its entirity below, as it might be interesting to glance over and see different kinds of combinations that resolution might create.

instance ResultsReport KragiiWormsEvent KragiiWormsChoice KragiiResults where
    report fId date event choice results =
        let
            content = KragiiNews { kragiiNewsPlanetId = kragiiWormsPlanetId event
                                 , kragiiNewsPlanetName = kragiiWormsPlanetName event
                                 , kragiiNewsSystemId = kragiiWormsSystemId event
                                 , kragiiNewsSystemName = kragiiWormsSystemName event
                                 , kragiiNewsExplanation = repText
                                 , kragiiNewsDate = timeCurrentTime date
                                 }
        in
            mkNews fId date $ KragiiResolution content
        where
            repText = header choice <> " " <> removed choice (WormsRemoved `elem` results) <> " " <> injury <> " " <> destruction <> " "

            header (Just EvadeWorms) = "Local farmers had chosen to work on their fields, while avoiding the kragii worms."
            header (Just AttackWorms) = "Local farmers had decided to attack the worms with chemicals and burning."
            header (Just TameWorms) = "Decision to try and tame the kragii had been taken."
            header Nothing = "No decision what to do about worms had been taken."

            removed (Just EvadeWorms) True = "After some time, there has been no new kragii sightings and it seems that the threat is now over."
            removed (Just AttackWorms) True = "Attacks seem to have worked and there has been no new kragii sightings."
            removed (Just TameWorms) True = "Kragii has been tamed and put into use of improving soil quality."
            removed Nothing True = "Despite farmers doing nothing at all about the situation, kragii worms disappeared eventually."
            removed (Just EvadeWorms) False = "Kragii are still present on the planet and hamper farming operations considerability."
            removed (Just AttackWorms) False = "Despite the best efforts of farmers, kragii threat is still present."
            removed (Just TameWorms) False = "Taming of the worms was much harder than anticipated and they remain wild."
            removed Nothing False = "While farmers were debating best course of action, kragii reigned free and destroyed crops."

            injury = if FarmersInjured `elem` results
                        then "Some of the personnel involved in the event were seriously injured."
                        else "There are no known reports of personnel injuries."

            totalDestroyed = mconcat $ map (x -> case x of
                                                    CropsDestroyed n -> n
                                                    _ -> mempty) results
            destruction = if totalDestroyed > RawResource 0
                            then "In the end, " <> pack (show (unRawResource totalDestroyed)) <> " units of harvest was destroyed."
                            else "Despite of all this, no harvest was destroyed."

While there are still pieces left that need a bit work or are completely missing, the overall structure is in place. While this one took quite a bit of work to get working, I’m hoping that the next special event will be a lot easier to implement. Thanks for listening the episode.

Easiest way to catch me nowdays is either via email or on fediverse where I’m tuturto@mastodon.social



hpr2746 :: My software part 2

More about the software I use regularly on Linux

Hosted by Tony Hughes AKA TonyH1212 on 2019-02-11 is flagged as Clean and released under a CC-BY-SA license.
Tags: Linux Mint 19.1,utilities.
Listen in ogg, spx, or mp3 format. Comments (0)

Good day to all in HPR land, this is Tony Hughes coming to you from Blackpool in the UK again. This is a second instalment about some of the software I use on Linux Mint 19.1, on a regular basis. So without further ado lets get on with the show.

  • USB Image writer

  • VirtualBox – Virtualisation software to virtualise x86 and AMD64 bit PC’s

  • OBS – Open Broadcast software

  • Brasero/XFburn – CD/DVD writing software

  • GIMP – GNU Image manipulation Program

So that’s it for this episode. I’ll be back to talk about some of the utilities I use on Mint on another show. This is Tony Hughes signing off for now.


Previous five weeks

hpr2745 :: My YouTube Subscriptions #1 hosted by Ahuka

Released: 2019-02-08. Duration: 00:21:02. Flag: Clean. Series: YouTube Subscriptions.
Tags: YouTube, Channels, Subscriptions.
Part one of my list of subscribed channels

hpr2744 :: Yet Another Rambling Drive Into Work hosted by MrX

Released: 2019-02-07. Duration: 00:33:42. Flag: Explicit.
Tags: Podcast, Cars.
Yet another rambling attempt at making a show on the way into work

hpr2743 :: Character build in the d20 system hosted by klaatu

Released: 2019-02-06. Duration: 01:05:49. Flag: Clean. Series: Information Underground.
Tags: Starfinder,RPG,character,build.
Klaatu and Lostnbronx build an RPG character in the d20 system of Starfinder

hpr2742 :: SAP Hana Certification Directory hosted by JWP

Released: 2019-02-05. Duration: 00:18:05. Flag: Clean.
Tags: SAP HANA,certification.
How the SAP Hana certification works

hpr2741 :: HPR Community News for January 2019 hosted by HPR Volunteers

Released: 2019-02-04. Duration: 01:16:38. Flag: Explicit. Series: HPR Community News.
Tags: Community News.
Yannick Dave and Ken talk about shows released and comments posted in January 2019

hpr2740 :: Pop!_OS 18.10 (quick) review hosted by Yannick the french guy from Switzerland

Released: 2019-02-01. Duration: 00:07:18. Flag: Clean.
Tags: linux,distro,distribution,pop_os,system76,ubuntu.
In this episode, Yannick does a quick review of Pop OS 18.10

hpr2739 :: Bash Tips - 19 hosted by Dave Morriss

Released: 2019-01-31. Duration: 00:25:53. Flag: Explicit. Series: Bash Scripting.
Tags: Bash,array,declare,typeset,local,readonly,read,mapfile,readarray.
Arrays in Bash (part 4)

hpr2738 :: My Applications hosted by Tony Hughes AKA TonyH1212

Released: 2019-01-30. Duration: 00:03:49. Flag: Clean.
Tags: productivity software.
just a short show on the applications I use on my Linux Mint Box

hpr2737 :: My Pioneer RT-707 Reel-to-Reel Tape Deck hosted by Jon Kulp

Released: 2019-01-29. Duration: 00:23:01. Flag: Clean.
Tags: audio, vintage audio, stereo components, audio tape, recording.
An intro to more of my legacy audio equipment.

hpr2736 :: Response to show 2720 hosted by Dave Morriss

Released: 2019-01-28. Duration: 00:18:24. Flag: Explicit. Series: Bash Scripting.
Tags: Bash,ShellCheck.
Some suggestions on how to improve a Bash script

hpr2735 :: Soffritto hosted by Tony Hughes AKA TonyH1212

Released: 2019-01-25. Duration: 00:02:18. Flag: Clean. Series: Cooking.
Tags: Food, cookery, how to, food preparation.
A short episode on a common cookery technique

hpr2734 :: Mashpodder hosted by MrX

Released: 2019-01-24. Duration: 00:18:59. Flag: Explicit.
Tags: Podcast, ncurses, commandline.
A poor rushed attempt at covering the excellent podcast client mashppoder

hpr2733 :: Writing Web Game in Haskell - News and Notifications hosted by tuturto

Released: 2019-01-23. Duration: 00:47:17. Flag: Clean.
Tags: haskell, yesod.
tuturto talks about the game they're writing in Haskell and convoluted news system they made.

hpr2732 :: Storytelling formula compliance hosted by klaatu

Released: 2019-01-22. Duration: 00:28:12. Flag: Explicit. Series: Information Underground.
Tags: story, character, plot, writing.
Telling a story? want a reaction? USE THE FORMULA

hpr2731 :: My 8 bit Christmas hosted by Andrew Conway

Released: 2019-01-21. Duration: 00:26:19. Flag: Clean.
Tags: retro,BBC,8bit,assembler.
I got a new, old computer for Christmas - an Acorn BBC microcomputer model B.

hpr2730 :: Resizing images for vcard on Android hosted by Ken Fallon

Released: 2019-01-18. Duration: 00:11:28. Flag: Explicit.
Tags: GraphicsMagick, ImageMagick, VCard, Android, LinageOS.
Automating the steps needed to get images formatted for VCard import into Android phones

hpr2729 :: Bash Tips - 18 hosted by Dave Morriss

Released: 2019-01-17. Duration: 00:31:38. Flag: Explicit. Series: Bash Scripting.
Tags: Bash,array,indexed array,associative array,parameter expansion.
Arrays in Bash (part 3)

hpr2728 :: The Unreliable Narrator In Storytelling hosted by lostnbronx

Released: 2019-01-16. Duration: 00:13:34. Flag: Clean. Series: Random Elements of Storytelling.
Tags: stories,storytelling,narration,lostnbronx.
Lostnbronx looks at unreliable narrators and narrative techniques in stories.

hpr2727 :: Passwords hosted by Edward Miro / c1ph0r

Released: 2019-01-15. Duration: 00:07:47. Flag: Clean. Series: Privacy and Security.
Tags: Information Security for Everyone.
How to do passwords better.

hpr2726 :: Home Theater - Part 2 Software (High Level) hosted by operat0r

Released: 2019-01-14. Duration: 00:20:49. Flag: Clean.
Tags: kodi, deluge,Sonarr,Plex,Subsonic,SpiderOakONE,Zoneminder,Borg Backup,rclone,Redshift,Audacity.
I go over a high level of my notes for the software on my Media box as it relates to TV/Movies/Music

hpr2725 :: The Illumos Shutdown Command Explained hosted by klaatu

Released: 2019-01-11. Duration: 00:13:32. Flag: Clean.
Tags: sys admin,systems,unix,illumos.
A short pod cast about the Illumos shutdown command

hpr2724 :: Using a DIN Rail to mount a Raspberry Pi hosted by Dave Morriss

Released: 2019-01-10. Duration: 00:09:09. Flag: Explicit.
Tags: 3D printing,DIN rail,Raspberry Pi.
I created DIN rail fittings for attaching my RPi 3B+ and an SSD disk

hpr2723 :: Using Elm in context of 4X game client hosted by tuturto

Released: 2019-01-09. Duration: 00:44:31. Flag: Clean.
Tags: elm.
tuturto talks their decisions on structuring Elm application

hpr2722 :: RAID 6 a short description hosted by JWP

Released: 2019-01-08. Duration: 00:02:30. Flag: Explicit.
Tags: Raid6.
How Raid 6 works

hpr2721 :: HPR Community News for December 2018 hosted by HPR Volunteers

Released: 2019-01-07. Duration: 01:10:47. Flag: Explicit. Series: HPR Community News.
Tags: Community News.
HPR Volunteers talk about shows released and comments posted in December 2018

hpr2720 :: Download youtube channels using the rss feeds hosted by Ken Fallon

Released: 2019-01-04. Duration: 00:24:07. Flag: Explicit.
Tags: youtube, youtube-dl, channels, playlists, xmlstarlet.
Ken shares a script that will allow you to quickly keep up to date on your youtube subscriptions

hpr2719 :: Bash Tips - 17 hosted by Dave Morriss

Released: 2019-01-03. Duration: 00:34:16. Flag: Explicit. Series: Bash Scripting.
Tags: Bash,array,indexed array,associative array.
Arrays in Bash (part 2)

hpr2718 :: Genre In Storytelling hosted by lostnbronx

Released: 2019-01-02. Duration: 00:12:30. Flag: Clean.
Tags: stories,storytelling,genre,lostnbronx.
Lostnbronx takes a look at the importance of genre in storytelling.

hpr2717 :: Mobile Device Security hosted by Edward Miro / c1ph0r

Released: 2019-01-01. Duration: 00:10:21. Flag: Explicit.
Tags: Mobile Device Security.
Cell phone cyber security 101

hpr2716 :: Really Simple YouTube hosted by Thaj Sara

Released: 2018-12-31. Duration: 00:07:21. Flag: Clean.
Tags: RSS, YouTube, PeerTube, TInyTinyRSS, Internet Video.
Thaj explains how he makes YouTube come to him using RSS feeds

hpr2715 :: About ONAP hosted by JWP

Released: 2018-12-28. Duration: 00:10:18. Flag: Explicit. Series: Networking.
Tags: Networking,ONAP,Open Networking Automation Platform.
The Linux foundations ONAP project all about it

hpr2714 :: Airplane stalls and Angle of Attack hosted by Brian in Ohio

Released: 2018-12-27. Duration: 00:16:35. Flag: Clean.
Tags: aircraft,flight,stall.
A primer on why airplanes quit flying

hpr2713 :: Resources in 4x game hosted by tuturto

Released: 2018-12-26. Duration: 00:20:52. Flag: Clean.
Tags: haskell.
One way to implement data types for raw resources in Haskell

hpr2712 :: Steganography hosted by klaatu

Released: 2018-12-25. Duration: 00:21:30. Flag: Clean.
Tags: steganography,message,secret decoder ring.
Klaatu wraps up his miniseries about steganography.

hpr2711 :: Raspberry Pi 3A+ Review hosted by Yannick the french guy from Switzerland

Released: 2018-12-24. Duration: 00:05:36. Flag: Clean.
Tags: raspberry pi, review.
In this episode of HPR, I will do a quick review of the Raspberry Pi 3A+.

hpr2710 :: Youtube downloader for channels hosted by Ken Fallon

Released: 2018-12-21. Duration: 00:14:04. Flag: Explicit.
Tags: youtube, youtube-dl.
A followup to hpr2675 how you can download an entire youtube channel for local playout

hpr2709 :: Bash Tips - 16 hosted by Dave Morriss

Released: 2018-12-20. Duration: 00:24:00. Flag: Explicit. Series: Bash Scripting.
Tags: Bash,array,indexed array,associative array.
Arrays in Bash (part 1)

hpr2708 :: Ghostscript hosted by klaatu

Released: 2018-12-19. Duration: 00:22:31. Flag: Clean. Series: Privacy and Security.
Tags: pdf, ebook, bloat, print.
Klaatu talks about manipulating PDFs with gs and pdf-stapler

hpr2707 :: Steganalysis 101 hosted by Edward Miro / c1ph0r

Released: 2018-12-18. Duration: 00:14:24. Flag: Clean.
Tags: Steganalysis, steganography.
Steganalysis is the process of identifying the presence of, and decrypting, steganography.

hpr2706 :: Why I love the IBM AS/400 computer systems hosted by Jeroen Baten

Released: 2018-12-17. Duration: 00:28:34. Flag: Explicit.
Tags: as400, ibm, computing, midrange.
A short talk about how I came to love the IBM As/400 systems and why.

Older Shows

Get a full list of all our shows.