1. IT-Security >
  2. Podcasts


ArabicEnglishFrenchGermanGreekItalianJapaneseKoreanPersianPolishPortugueseRussianSpanishTurkishVietnamese

Podcasts


Suchen

News RSS Quellen: 1x
News Kategorien unterhalb von Podcasts: 0x
News RSS Feeds dieser Podcasts Kategorie: RSS Feed Podcasts
Benutze Feedly zum Abonieren.Folge uns auf feedly
Download RSS Feed App für Windows 10 Store (Leider gibt es nicht mehr viele Extensions mit welchen Sie RSS-Feeds in einer Software abonieren können. Der Browser Support für RSS-Feeds wurde eingestellt (Firefox,Chrome).

Eigene IT Security Webseite / Blog / Quelle hinzufügen

Seitennavigation

Seite 1 von 15 Seiten (Bei Beitrag 1 - 35)
501x Beiträge in dieser Kategorie

Nächste 2 Seite | Letzte Seite

[ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ 10 ] [ 11 ]

HPR2901: Describing how I listen to podcasts PART 3

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

In this series I cover how I listen to podcasts and how the process has changed over the years. In this episode I cover the 1st add-on board I purchased for one of my raspberry pi’s I then go on to explain what I do with it.

    sudo apt-get install python{,3}-pifacedigitalio

Picture 1
Picture 1, shows the Piface Digital IO board installed on top of my raspberry pi

Picture 2
Picture 2, shows the extension board I built. The extension board increases the number of available LED’s and switches. The board is attached via a ribbon cable with the ends of the wire inserted into the green and orange screw down chocolate blocks attached to the Piface Digital IO board.

Explanation of how to read a binary display

The board I built which attaches to the Piface Digital board has a total of 8 LED’s. I use the 8 LED’s to display a number in binary format. In binary each LED has only two values either on or off, with 1 LED you can count to 1 with two LED’s you can count to 3. This may seem confusing if you’ve never dealt with binary before. Starting from the right each subsequent LED represents double the value of the previous one so the 1st LED has a value of 1 the 2nd LED has a value of 2, the third LED has a value of 4 and so on. See below

LED Number   8   7   6   5  4  3  2  1
LED VALUES 128, 64, 32, 16, 8, 4, 2, 1

LED on represents 1, LED off represents 0

[Example 1] 0 0 0 0 0 0 0 1 [Represented value 1]
1st LED on value = 1

[Example 2] 0 0 0 0 0 0 1 1 [Represented value 3]
1st and 2nd LED on, LED VALUE 1 + 2 = 3

[Examples 3] 0 0 0 0 1 0 1 0 [Represented value 10]
2nd and 4th LED on, LED VALUE 2 + 8 = 10

With practice it gets easy to convert from binary to decimal, at my work we still have a very old computer which contains a front panel with LED’s and binary switches. To load the computer instructions must be loaded in binary using flip switches and LED’s with practice it becomes second nature.

Links


News Bewertung

Weiterlesen Weiterlesen

HPR2900: Better Social Media 01 - Introduction

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

While many people like to use social media, platforms like Twitter and Facebook are very unsatisfying, not to mention inimical to your security and privacy. Fortunately there are alternatives we can try, and in this series I want to explore a few of them. https://www.zwilnik.com/?page_id=1025

Links:


News Bewertung

Weiterlesen Weiterlesen

HPR2899: Endeavour OS

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Hi to all you out there in HPR land, this is a quick show to help out with the current summer shortage of shows.

So over the last few months I’ve been busy with my new Podcasting career, well it fills in the time now I’m retired. Anyway the Distro-hoppers show has been getting a regular audience and recently we decided to branch out a little and open up the review format to the audience, you can find details of how to do that on the Blog.

The most recent show was a review of the new Endeavour OS which has risen from the ashes of Antergos Linux an Arch based OS. Well I decided to use this opportunity to delve into the world of Arch for the first time with Endeavour OS and I can report I was pleasantly surprised with this slick iteration of Arch. OK when you first install Endeavour all you will have is a new XFCE 4.14 DE and some basic software to get you started, you are then expected to do a little research to find out how to install other software you need to get your PC setup the way you like but all the basic information on package management is on the Endeavour OS Wiki and also on the Arch Linux Wiki.

If you have thought of trying Arch Linux but would prefer to start with a running Desktop from install then Endeavour OS is definitely the place to start. I have been running it as my daily Driver for over a month and have fallen in love with it.
My full review is on the Distrohoppers Blog as is a link to the Audio of the show.

That’s it for this time, this is Tony Hughes saying goodbye until next time.

https://distrohoppersdigest.blogspot.com/

https://endeavouros.com/

https://www.archlinux.org/


News Bewertung

Weiterlesen Weiterlesen

HPR2898: Modeling people in space game

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

People are what makes dynasty simulators interesting and this episode will be about them. There isn’t much code this time, mainly just how data is organized. Topic is long and split over several episodes.

Some people in game are controlled by computer, while some are controlled by player. There’s no difference on what each can do in game, computer is basically just filling in for players when there aren’t enough players.

There’s plenty of data about people, spread over several entities and database tables. Main one is Person, which stores name, gender, sex, date of birth and some stats (and then some more).

There are lots of various ways of naming people and I chose to model three for the starters:

data PersonName =
    RegularName FirstName FamilyName (Maybe Cognomen)
    | SimpleName FirstName (Maybe Cognomen)
    | RegalName FirstName FamilyName RegnalNumber (Maybe Cognomen)
    deriving (Show, Read, Eq)

The higher the rank, more complicated names you tend to have (for some reason). Later on I’ll try and see if I can add more varied names, like matronyms and patronyms.

Sex and gender I’m modeling with simple system of two enumerations, sex can be Female, Male or Intersex, while gender has values Man, Woman, Agender and Nonbinary. System is coarse, but should be enough to get started with the game. Later on, this can be expanded to more nuanced system.

Traits are defining features of people. These include things like brave, coward, ambitious, content, honest and such. Values are binary, character either is brave or not. And character can’t be brave and coward at the same time.

Relations are modeled as PersonRelation and thus stored in person_relation table:

Relation json
    originatorId PersonId
    targetId PersonId
    type RelationType
    visibility RelationVisibility
    deriving Show Read Eq

I find this corner of the puzzle particular interesting. This models who is parent or child, who is friend or rival. Interconnected web created by relations isn’t completely visible to players (or any other person in game). Relations have visibility, modeled as RelationVisibility, which tells how visible it is. Public ones are known by everyone, family relations are limited to small group of people and secret relations are only known by those who are in the fold. One aspect of the game is acquiring this information.

Intel is modeled as HumanIntelligence and stored in human_intelligence table:

HumanIntelligence json
    personId PersonId
    ownerId PersonId
    level PersonIntel
    deriving Show Read Eq

Essentially it just lists which character has what information about certain other character. So when displaying information to players, this table has to be referenced in order to know how much to reveal to them.

Different types of intels are listed as PersonIntel:

data PersonIntel =
    Stats
    | Demesne
    | FamilyRelations
    | SecretRelations
    | Opinions OpinionIntel
    | Traits
    deriving (Show, Read, Eq)

Person related data is sent back to client in PersonReport record (I’m not copying it here as it’s relatively large). We can have a look on how one field is processed.

For example, in case of traits. PersonReport has field personReportTraits :: !(Maybe [TraitReport]). Exclamation mark in the beginning of type instructs Haskell that this value should be computed immediately when record is created and not left for later. I’m doing this as I know for sure that it’ll always be used and there’s no advantage on delaying computation for the time when it might be needed.

Report creating (high level):

personReportTraits = if Traits `elem` targetIntel
                        then Just $ traitReport <$> targetTraits
                        else Nothing

That first checks that Traits level of intel is available and then creates list of trait reports (one for each trait person has). These have things like trait name, description, trait type and how long the trait is valid. Having separate name and description fields makes it easier to work on client side as I don’t have to come up with descriptions there anymore. I can just use what the server sends to me and be happy.

Comments, questions and feedback are welcome. Best way to catch me nowadays is email or fediverse where I’m [email protected].


News Bewertung

Weiterlesen Weiterlesen

HPR2897: Stardrifter RPG Playtest Part 03

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode is Part 3 of the Stardrifter role-playing game playtest. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this part, we continue to go over the rules of the game, and then start into the adventure!

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2896: Orange PI Zero LTS version

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen


News Bewertung

Weiterlesen Weiterlesen

HPR2895: The work of fire fighters, part 2

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Continued general basic knowledge of fire fighting.
Also an extended invitation to ask questions in the comments.
ps: I started making podcasts one year ago! o/


News Bewertung

Weiterlesen Weiterlesen

HPR2894: Repairing a Musical Instrument Case

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

In this episode I talk about repairing the case for a Vietnamese Đàn tranh, a zither-like instrument which was donated to the School of Music by a member of the community. I also demonstrate the instrument as best I can so that you can hear what it sounds like.

See the Flickr photo album that accompanies this show by clicking the image below.

Dan Tranh Case Repair

Links

Credits


News Bewertung

Weiterlesen Weiterlesen

HPR2893: Whats in the box! Part 2

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

In this short follow up episode NYbill troubleshoots the Tremlo guitar kit Timttmy sent him.

Here is a hint, there were two problems, not just one.

Pics for the episode:

http://media.gunmonkeynet.net/u/nybill/collection/whats-in-the-box-part-2/


News Bewertung

Weiterlesen Weiterlesen

HPR2892: Stardrifter RPG Playtest Part 02

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode is Part 2 of the Stardrifter role-playing game playtest. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this part, we continue to go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2891: HPR Community News for August 2019

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

New hosts

There were no new hosts this month.

Last Month's Shows

Id Day Date Title Host
2869 Thu 2019-08-01 building a bike, following in John Kulp's footsteps Brian in Ohio
2870 Fri 2019-08-02 Hierarchy of Evidence Ahuka
2871 Mon 2019-08-05 HPR Community News for July 2019 HPR Volunteers
2872 Tue 2019-08-06 Shoe Lace Tips MrX
2873 Wed 2019-08-07 Death Angel - Card game tuturto
2874 Thu 2019-08-08 Repair of G.E. Variable Speed Cassette Recorder Jon Kulp
2875 Fri 2019-08-09 cutting up the frames Brian in Ohio
2876 Mon 2019-08-12 Sausage Orzotto Windigo
2877 Tue 2019-08-13 Using Zenity with Pdmenu Dave Morriss
2878 Wed 2019-08-14 Type classes in Haskell tuturto
2879 Thu 2019-08-15 Describing how I listen to podcasts PART 1 MrX
2880 Fri 2019-08-16 Evaluating a Study Ahuka
2881 Mon 2019-08-19 Automatically split album into tracks in Audacity Ken Fallon
2882 Tue 2019-08-20 ONICS Part 1: Basic Commands Gabriel Evenfire
2883 Wed 2019-08-21 Pass the pigs tuturto
2884 Thu 2019-08-22 TASCAM Porta 02 MiniStudio 4-Track Cassette Recorder Demonstration Jon Kulp
2885 Fri 2019-08-23 ONICS Part 2: Filtering and Extraction Gabriel Evenfire
2886 Mon 2019-08-26 INFOSECOND operat0r
2887 Tue 2019-08-27 Stardrifter RPG Playtest Part 01 lostnbronx
2888 Wed 2019-08-28 Pattern matching in Haskell tuturto
2889 Thu 2019-08-29 Describing how I listen to podcasts PART 2 MrX
2890 Fri 2019-08-30 Penguicon 2019 Report Ahuka

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 24 comments in total.

Past shows

There are 7 comments on 2 previous shows:

  • hpr2859 (2019-07-18) "HPR NYE Show 2018-2019 part 7" by Honkeymagoo.
    • Comment 3: Mike Ray on 2019-08-05: "First hour"
    • Comment 4: MrsXoke on 2019-08-05: "To Mike Ray"
    • Comment 5: Mike Ray on 2019-08-06: "To Mike Ray"
    • Comment 6: Mike Ray on 2019-08-06: "Active shooter drills"
    • Comment 7: Mike Ray on 2019-08-06: "Faith and values"
    • Comment 8: folky on 2019-08-08: "You can fastforward"

  • hpr2863 (2019-07-24) "Simplified application architectures for improved security" by Beeza.
    • Comment 1: clacke on 2019-08-14: "Dynamic vs static linking doesn't matter"

This month's shows

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

  • hpr2869 (2019-08-01) "building a bike, following in John Kulp's footsteps" by Brian in Ohio.
    • Comment 1: Jon Kulp on 2019-08-01: "Recycled Recumbents"

  • hpr2876 (2019-08-12) "Sausage Orzotto" by Windigo.
    • Comment 1: Bookewyrmm on 2019-08-12: "Salt"
    • Comment 2: Windigo on 2019-08-17: "Re: Salt"
    • Comment 3: Dave Morriss on 2019-08-20: "Loved this. I was right there with you in the kitchen"

  • hpr2881 (2019-08-19) "Automatically split album into tracks in Audacity" by Ken Fallon.
    • Comment 1: Jonathan Kulp on 2019-08-22: "Automation is nice"

  • hpr2882 (2019-08-20) "ONICS Part 1: Basic Commands" by Gabriel Evenfire.
    • Comment 1: Dave Morriss on 2019-08-22: "Great project and excellent show"
    • Comment 2: Gabriel Evenfire on 2019-08-25: "Good to hear"

  • hpr2884 (2019-08-22) "TASCAM Porta 02 MiniStudio 4-Track Cassette Recorder Demonstration" by Jon Kulp.
    • Comment 1: Clinton Roy on 2019-08-22: "fantastic"
    • Comment 2: tuturto on 2019-08-22: "awesome"
    • Comment 3: jezra on 2019-08-22: "super fun!"
    • Comment 4: Jon Kulp on 2019-08-22: "By ear"
    • Comment 5: mcnalu on 2019-08-24: "4tracks4TW"
    • Comment 6: Jon Kulp on 2019-08-24: "Can’t bounce"
    • Comment 7: johanv on 2019-08-29: "great show"

  • hpr2887 (2019-08-27) "Stardrifter RPG Playtest Part 01" by lostnbronx.
    • Comment 1: tuturto on 2019-08-27: "Eagerly waiting for more"
    • Comment 2: Ken Fallon on 2019-08-28: "A future podcast in the future feed"

  • hpr2890 (2019-08-30) "Penguicon 2019 Report" by Ahuka.
    • Comment 1: Dave Morriss on 2019-08-31: "solder/"sodder"/souder"

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:

http://hackerpublicradio.org/pipermail/hpr_hackerpublicradio.org/2019-August/thread.html

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

Tags and Summaries

Thanks to the following contributor for sending in updates in the past month: Dave Morriss

Over the period tags and/or summaries have been added to 10 shows which were without them.

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.


News Bewertung

Weiterlesen Weiterlesen

HPR2890: Penguicon 2019 Report

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Penguicon 2019 is a combined technology and science fiction convention in Southfield, Michigan, a suburb of Detroit, and presents over 500 hours of programming over the entire weekend. Of this, around 100 hours are open source, tech-related. In this episode I tell you about my own personal experience at Penguicon this year.

Links


News Bewertung

Weiterlesen Weiterlesen

HPR2889: Describing how I listen to podcasts PART 2

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Short Summary

In this series I cover how I listen to podcasts and how the process has change over the years. In this episode I cover the hardware I’ve used over the years to listen to podcasts.

  • Link to HPR 2112 (Home Server) episode mentioned in this podcast
    http://hackerpublicradio.org/eps.php?id=2112

  • Link to HPR 2106 (Hpodder) Episode mentioned in this podcast
    http://hackerpublicradio.org/eps.php?id=2106

  • The cordless headphones I use are analogue cordless headphones they operate in the UHF 860 MHz RF spectrum and use Frequency modulation

  • (Picture 01) shows a pair of JVC cordless headphones, these were my first pair of cordless headphones, from memory they were reasonably comfortable and lasted a reasonably long time, they eventually gave way when the strap along the top completely split if you look carefully you can see evidence of this in the picture. Picture-01.JPG

  • I think my 2nd set pair of cordless headphones were made by Phillips, unfortunately I don’t have a picture of these. The headphones were too big and kept falling from my head.

  • (Picture 02) shows a pair of Sony headphones that I can’t even remember owning! I’ve lost count of how many cordless headphones I’ve owned over the years, these were also too big and regularly fell off my head, there are probably other pairs which I have forgotten about. It took a lot of trial an error to find a pair that would fit properly. Picture-02.JPG

  • I think my 3rd set of cordless headphones were a cheap pair from Liddles, unfortunately I don’t have a picture of these again these were also too big.

  • (Picture 03) Shows my current set of cordless headphones, unfortunately my camera refused to work while taking this picture so you’ll not be able to identify the manufacturer which is a great pity as they are absolutely great also the lighting in here is very bad so you won’t be able to make out the writing printed on them :) Picture-03.JPG

  • Compaq N610C laptop
    http://1.bp.blogspot.com/_73lLV6srqwY/SxB7dASme9I/AAAAAAAAAVU/QsNP-O2chaU/s1600/missionaccomplished.jpg

  • Screen
    https://en.wikipedia.org/wiki/GNU_Screen

  • EEE PC Laptop
    https://en.wikipedia.org/wiki/Asus_Eee_PC

  • Pictures (04 and 05) are of my Nokia N810 Picture-04.JPG
    Picture-05.JPG

  • Below is a link from wikipedia covering the Nokia N810.
    https://en.wikipedia.org/wiki/Nokia_N810

  • Links to shows where klaatu references the Nokia N770 which came out before the Nokia N810 but is very similar
    http://hackerpublicradio.org/eps.php?id=0228
    http://hackerpublicradio.org/eps.php?id=0416

  • Nexus 7, first generation
    https://en.wikipedia.org/wiki/Nexus_7_(2012)

  • Psion 3C
    https://en.wikipedia.org/wiki/Psion_Series_3#Psion_Series_3c

  • Raspberry pi
    https://en.wikipedia.org/wiki/Raspberry_Pi


News Bewertung

Weiterlesen Weiterlesen

HPR2888: Pattern matching in Haskell

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Pattern matching is one of those features of Haskell that immediately got me interested as it reduces amount of branching inside of functions I write. Basic idea is that if value constructors are for making data, pattern matching is for taking it apart.

First example is a function that takes a Bool and returns a respective String:

boolToString :: Bool -> String
boolToString n =
    if n
        then "True"
        else "False"

Nothing too fancy, just an if expression inside a function. We can move that if out of there though and define exactly same functionality, but with patterns:

boolToString :: Bool -> String
boolToString True =
    "True"

boolToString False =
    "False"

There’s one definition for boolToString, but two different patterns used.

Second example is bit more complex, this time we have Maybe Int that is being turned into String. Maybe has two value constructors Nothing and Just a. We have two cases for Just, specific one for when it’s Just 1 and more general one Just n that takes care of rest of the cases.

isBig :: Maybe Int -> String
isBig Nothing =
    "Not at all"

isBig (Just 1) =
    "Just perfect"

isBig (Just n) =
    if n < 10
        then "Just slightly"
        else "Definitely is"

Some example usage:

> isBig Nothing
"Not at all"
> isBig $ Just 0
"Just perfect"
> isBig $ Just 50
"Definitely is"

Pattern matching isn’t limited to algebraic datatypes that we have been working with so far. We can do same things with records. Below is an function used to calculate total fee when cost and customer are known. Each customer can have their own discount percentage, but in addition we’re giving 10% discount to VIP customers:

data Customer = Customer
    { customerName :: String
    , customerDiscountPct :: Double
    , vipCustomer :: Bool
    }

totalFee :: Double -> Customer -> Double
totalFee bill [email protected](Customer { vipCustomer = True }) =
    bill * 0.9 * customerDiscountPct cust

totalFee bill cust =
    bill * customerDiscountPct cust

There’s two cases of totalFee function. First one is for when passed in Customer has vipCustomer field True. Second one takes care of general case. In the first case we’re using @ to bind Customer as a whole to cust name.

Lists can be matched too. The basic idea is exactly the same:

  • (x:xs) matches a list with at least one item, x is first item, xs is rest of the items (might be an empty list)
  • (x:y:_) matches two first items in a list of at least two items, x is first, y is second, _ is rest
  • [] matches empty list
  • (x:[]) matches list of exactly one item

Underscore _ matches to everything without binding value to a name. This is useful when you don’t care about exact value, so you don’t want to give it a name. One could give it a name, but compiler will issue a warning if there are unused values in the code.

Next example is recursively counting amount if items in a list using pattern matching:

count :: [a] -> Int
count [] =
    0

count (x:xs) =
    1 + count xs

Fibonacci series is series of number which starts with 0, 1 and then rest of the numbers are sum of two previous ones: 0, 1, 1, 2, 3, 5, 8…

To calculate number in series, we can write following code (this is extremely slow way of calculating them by the way):

fibonacci :: Int -> Int
fibonacci 0 =
    0

fibonacci 1 =
    1

fibonacci n =
    fibonacci (n - 1) + fibonacci (n - 2)

Last trick in our sleeve for now is case expression. This allows us to do pattern matching inside of a function. Otherwise it works in the same way. Our fibonacci function could be defined as:

fibonacci :: Int -> Int
fibonacci n =
    case n of
        0 ->
            0

        1 ->
            1

        n ->
            fibonacci (n - 1) + fibonacci (n - 2)

Questions, comments and feedback are welcome. Best way to catch me nowadays is either email or in fediverse where I’m [email protected]


News Bewertung

Weiterlesen Weiterlesen

HPR2888: Pattern matching in Haskell

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Pattern matching is one of those features of Haskell that immediately got me interested as it reduces amount of branching inside of functions I write. Basic idea is that if value constructors are for making data, pattern matching is for taking it apart.

First example is a function that takes a Bool and returns a respective String:

boolToString :: Bool -> String
boolToString n =
    if n
        then "True"
        else "False"

Nothing too fancy, just an if expression inside a function. We can move that if out of there though and define exactly same functionality, but with patterns:

boolToString :: Bool -> String
boolToString True =
    "True"

boolToString False =
    "False"

There’s one definition for boolToString, but two different patterns used.

Second example is bit more complex, this time we have Maybe Int that is being turned into String. Maybe has two value constructors Nothing and Just a. We have two cases for Just, specific one for when it’s Just 1 and more general one Just n that takes care of rest of the cases.

isBig :: Maybe Int -> String
isBig Nothing =
    "Not at all"

isBig (Just 1) =
    "Just perfect"

isBig (Just n) =
    if n < 10
        then "Just slightly"
        else "Definitely is"

Some example usage:

> isBig Nothing
"Not at all"
> isBig $ Just 0
"Just perfect"
> isBig $ Just 50
"Definitely is"

Pattern matching isn’t limited to algebraic datatypes that we have been working with so far. We can do same things with records. Below is an function used to calculate total fee when cost and customer are known. Each customer can have their own discount percentage, but in addition we’re giving 10% discount to VIP customers:

data Customer = Customer
    { customerName :: String
    , customerDiscountPct :: Double
    , vipCustomer :: Bool
    }

totalFee :: Double -> Customer -> Double
totalFee bill [email protected](Customer { vipCustomer = True }) =
    bill * 0.9 * customerDiscountPct cust

totalFee bill cust =
    bill * customerDiscountPct cust

There’s two cases of totalFee function. First one is for when passed in Customer has vipCustomer field True. Second one takes care of general case. In the first case we’re using @ to bind Customer as a whole to cust name.

Lists can be matched too. The basic idea is exactly the same:

  • (x:xs) matches a list with at least one item, x is first item, xs is rest of the items (might be an empty list)
  • (x:y:_) matches two first items in a list of at least two items, x is first, y is second, _ is rest
  • [] matches empty list
  • (x:[]) matches list of exactly one item

Underscore _ matches to everything without binding value to a name. This is useful when you don’t care about exact value, so you don’t want to give it a name. One could give it a name, but compiler will issue a warning if there are unused values in the code.

Next example is recursively counting amount if items in a list using pattern matching:

count :: [a] -> Int
count [] =
    0

count (x:xs) =
    1 + count xs

Fibonacci series is series of number which starts with 0, 1 and then rest of the numbers are sum of two previous ones: 0, 1, 1, 2, 3, 5, 8…

To calculate number in series, we can write following code (this is extremely slow way of calculating them by the way):

fibonacci :: Int -> Int
fibonacci 0 =
    0

fibonacci 1 =
    1

fibonacci n =
    fibonacci (n - 1) + fibonacci (n - 2)

Last trick in our sleeve for now is case expression. This allows us to do pattern matching inside of a function. Otherwise it works in the same way. Our fibonacci function could be defined as:

fibonacci :: Int -> Int
fibonacci n =
    case n of
        0 ->
            0

        1 ->
            1

        n ->
            fibonacci (n - 1) + fibonacci (n - 2)

Questions, comments and feedback are welcome. Best way to catch me nowadays is either email or in fediverse where I’m [email protected]


News Bewertung

Weiterlesen Weiterlesen

HPR2888: Pattern matching in Haskell

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Pattern matching is one of those features of Haskell that immediately got me interested as it reduces amount of branching inside of functions I write. Basic idea is that if value constructors are for making data, pattern matching is for taking it apart.

First example is a function that takes a Bool and returns a respective String:

boolToString :: Bool -> String
boolToString n =
    if n
        then "True"
        else "False"

Nothing too fancy, just an if expression inside a function. We can move that if out of there though and define exactly same functionality, but with patterns:

boolToString :: Bool -> String
boolToString True =
    "True"

boolToString False =
    "False"

There’s one definition for boolToString, but two different patterns used.

Second example is bit more complex, this time we have Maybe Int that is being turned into String. Maybe has two value constructors Nothing and Just a. We have two cases for Just, specific one for when it’s Just 1 and more general one Just n that takes care of rest of the cases.

isBig :: Maybe Int -> String
isBig Nothing =
    "Not at all"

isBig (Just 1) =
    "Just perfect"

isBig (Just n) =
    if n < 10
        then "Just slightly"
        else "Definitely is"

Some example usage:

> isBig Nothing
"Not at all"
> isBig $ Just 0
"Just perfect"
> isBig $ Just 50
"Definitely is"

Pattern matching isn’t limited to algebraic datatypes that we have been working with so far. We can do same things with records. Below is an function used to calculate total fee when cost and customer are known. Each customer can have their own discount percentage, but in addition we’re giving 10% discount to VIP customers:

data Customer = Customer
    { customerName :: String
    , customerDiscountPct :: Double
    , vipCustomer :: Bool
    }

totalFee :: Double -> Customer -> Double
totalFee bill [email protected](Customer { vipCustomer = True }) =
    bill * 0.9 * customerDiscountPct cust

totalFee bill cust =
    bill * customerDiscountPct cust

There’s two cases of totalFee function. First one is for when passed in Customer has vipCustomer field True. Second one takes care of general case. In the first case we’re using @ to bind Customer as a whole to cust name.

Lists can be matched too. The basic idea is exactly the same:

  • (x:xs) matches a list with at least one item, x is first item, xs is rest of the items (might be an empty list)
  • (x:y:_) matches two first items in a list of at least two items, x is first, y is second, _ is rest
  • [] matches empty list
  • (x:[]) matches list of exactly one item

Underscore _ matches to everything without binding value to a name. This is useful when you don’t care about exact value, so you don’t want to give it a name. One could give it a name, but compiler will issue a warning if there are unused values in the code.

Next example is recursively counting amount if items in a list using pattern matching:

count :: [a] -> Int
count [] =
    0

count (x:xs) =
    1 + count xs

Fibonacci series is series of number which starts with 0, 1 and then rest of the numbers are sum of two previous ones: 0, 1, 1, 2, 3, 5, 8…

To calculate number in series, we can write following code (this is extremely slow way of calculating them by the way):

fibonacci :: Int -> Int
fibonacci 0 =
    0

fibonacci 1 =
    1

fibonacci n =
    fibonacci (n - 1) + fibonacci (n - 2)

Last trick in our sleeve for now is case expression. This allows us to do pattern matching inside of a function. Otherwise it works in the same way. Our fibonacci function could be defined as:

fibonacci :: Int -> Int
fibonacci n =
    case n of
        0 ->
            0

        1 ->
            1

        n ->
            fibonacci (n - 1) + fibonacci (n - 2)

Questions, comments and feedback are welcome. Best way to catch me nowadays is either email or in fediverse where I’m [email protected]


News Bewertung

Weiterlesen Weiterlesen

HPR2888: Pattern matching in Haskell

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Pattern matching is one of those features of Haskell that immediately got me interested as it reduces amount of branching inside of functions I write. Basic idea is that if value constructors are for making data, pattern matching is for taking it apart.

First example is a function that takes a Bool and returns a respective String:

boolToString :: Bool -> String
boolToString n =
    if n
        then "True"
        else "False"

Nothing too fancy, just an if expression inside a function. We can move that if out of there though and define exactly same functionality, but with patterns:

boolToString :: Bool -> String
boolToString True =
    "True"

boolToString False =
    "False"

There’s one definition for boolToString, but two different patterns used.

Second example is bit more complex, this time we have Maybe Int that is being turned into String. Maybe has two value constructors Nothing and Just a. We have two cases for Just, specific one for when it’s Just 1 and more general one Just n that takes care of rest of the cases.

isBig :: Maybe Int -> String
isBig Nothing =
    "Not at all"

isBig (Just 1) =
    "Just perfect"

isBig (Just n) =
    if n < 10
        then "Just slightly"
        else "Definitely is"

Some example usage:

> isBig Nothing
"Not at all"
> isBig $ Just 0
"Just perfect"
> isBig $ Just 50
"Definitely is"

Pattern matching isn’t limited to algebraic datatypes that we have been working with so far. We can do same things with records. Below is an function used to calculate total fee when cost and customer are known. Each customer can have their own discount percentage, but in addition we’re giving 10% discount to VIP customers:

data Customer = Customer
    { customerName :: String
    , customerDiscountPct :: Double
    , vipCustomer :: Bool
    }

totalFee :: Double -> Customer -> Double
totalFee bill [email protected](Customer { vipCustomer = True }) =
    bill * 0.9 * customerDiscountPct cust

totalFee bill cust =
    bill * customerDiscountPct cust

There’s two cases of totalFee function. First one is for when passed in Customer has vipCustomer field True. Second one takes care of general case. In the first case we’re using @ to bind Customer as a whole to cust name.

Lists can be matched too. The basic idea is exactly the same:

  • (x:xs) matches a list with at least one item, x is first item, xs is rest of the items (might be an empty list)
  • (x:y:_) matches two first items in a list of at least two items, x is first, y is second, _ is rest
  • [] matches empty list
  • (x:[]) matches list of exactly one item

Underscore _ matches to everything without binding value to a name. This is useful when you don’t care about exact value, so you don’t want to give it a name. One could give it a name, but compiler will issue a warning if there are unused values in the code.

Next example is recursively counting amount if items in a list using pattern matching:

count :: [a] -> Int
count [] =
    0

count (x:xs) =
    1 + count xs

Fibonacci series is series of number which starts with 0, 1 and then rest of the numbers are sum of two previous ones: 0, 1, 1, 2, 3, 5, 8…

To calculate number in series, we can write following code (this is extremely slow way of calculating them by the way):

fibonacci :: Int -> Int
fibonacci 0 =
    0

fibonacci 1 =
    1

fibonacci n =
    fibonacci (n - 1) + fibonacci (n - 2)

Last trick in our sleeve for now is case expression. This allows us to do pattern matching inside of a function. Otherwise it works in the same way. Our fibonacci function could be defined as:

fibonacci :: Int -> Int
fibonacci n =
    case n of
        0 ->
            0

        1 ->
            1

        n ->
            fibonacci (n - 1) + fibonacci (n - 2)

Questions, comments and feedback are welcome. Best way to catch me nowadays is either email or in fediverse where I’m [email protected]


News Bewertung

Weiterlesen Weiterlesen

HPR2888: Pattern matching in Haskell

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Pattern matching is one of those features of Haskell that immediately got me interested as it reduces amount of branching inside of functions I write. Basic idea is that if value constructors are for making data, pattern matching is for taking it apart.

First example is a function that takes a Bool and returns a respective String:

boolToString :: Bool -> String
boolToString n =
    if n
        then "True"
        else "False"

Nothing too fancy, just an if expression inside a function. We can move that if out of there though and define exactly same functionality, but with patterns:

boolToString :: Bool -> String
boolToString True =
    "True"

boolToString False =
    "False"

There’s one definition for boolToString, but two different patterns used.

Second example is bit more complex, this time we have Maybe Int that is being turned into String. Maybe has two value constructors Nothing and Just a. We have two cases for Just, specific one for when it’s Just 1 and more general one Just n that takes care of rest of the cases.

isBig :: Maybe Int -> String
isBig Nothing =
    "Not at all"

isBig (Just 1) =
    "Just perfect"

isBig (Just n) =
    if n < 10
        then "Just slightly"
        else "Definitely is"

Some example usage:

> isBig Nothing
"Not at all"
> isBig $ Just 0
"Just perfect"
> isBig $ Just 50
"Definitely is"

Pattern matching isn’t limited to algebraic datatypes that we have been working with so far. We can do same things with records. Below is an function used to calculate total fee when cost and customer are known. Each customer can have their own discount percentage, but in addition we’re giving 10% discount to VIP customers:

data Customer = Customer
    { customerName :: String
    , customerDiscountPct :: Double
    , vipCustomer :: Bool
    }

totalFee :: Double -> Customer -> Double
totalFee bill [email protected](Customer { vipCustomer = True }) =
    bill * 0.9 * customerDiscountPct cust

totalFee bill cust =
    bill * customerDiscountPct cust

There’s two cases of totalFee function. First one is for when passed in Customer has vipCustomer field True. Second one takes care of general case. In the first case we’re using @ to bind Customer as a whole to cust name.

Lists can be matched too. The basic idea is exactly the same:

  • (x:xs) matches a list with at least one item, x is first item, xs is rest of the items (might be an empty list)
  • (x:y:_) matches two first items in a list of at least two items, x is first, y is second, _ is rest
  • [] matches empty list
  • (x:[]) matches list of exactly one item

Underscore _ matches to everything without binding value to a name. This is useful when you don’t care about exact value, so you don’t want to give it a name. One could give it a name, but compiler will issue a warning if there are unused values in the code.

Next example is recursively counting amount if items in a list using pattern matching:

count :: [a] -> Int
count [] =
    0

count (x:xs) =
    1 + count xs

Fibonacci series is series of number which starts with 0, 1 and then rest of the numbers are sum of two previous ones: 0, 1, 1, 2, 3, 5, 8…

To calculate number in series, we can write following code (this is extremely slow way of calculating them by the way):

fibonacci :: Int -> Int
fibonacci 0 =
    0

fibonacci 1 =
    1

fibonacci n =
    fibonacci (n - 1) + fibonacci (n - 2)

Last trick in our sleeve for now is case expression. This allows us to do pattern matching inside of a function. Otherwise it works in the same way. Our fibonacci function could be defined as:

fibonacci :: Int -> Int
fibonacci n =
    case n of
        0 ->
            0

        1 ->
            1

        n ->
            fibonacci (n - 1) + fibonacci (n - 2)

Questions, comments and feedback are welcome. Best way to catch me nowadays is either email or in fediverse where I’m [email protected]


News Bewertung

Weiterlesen Weiterlesen

HPR2888: Pattern matching in Haskell

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Pattern matching is one of those features of Haskell that immediately got me interested as it reduces amount of branching inside of functions I write. Basic idea is that if value constructors are for making data, pattern matching is for taking it apart.

First example is a function that takes a Bool and returns a respective String:

boolToString :: Bool -> String
boolToString n =
    if n
        then "True"
        else "False"

Nothing too fancy, just an if expression inside a function. We can move that if out of there though and define exactly same functionality, but with patterns:

boolToString :: Bool -> String
boolToString True =
    "True"

boolToString False =
    "False"

There’s one definition for boolToString, but two different patterns used.

Second example is bit more complex, this time we have Maybe Int that is being turned into String. Maybe has two value constructors Nothing and Just a. We have two cases for Just, specific one for when it’s Just 1 and more general one Just n that takes care of rest of the cases.

isBig :: Maybe Int -> String
isBig Nothing =
    "Not at all"

isBig (Just 1) =
    "Just perfect"

isBig (Just n) =
    if n < 10
        then "Just slightly"
        else "Definitely is"

Some example usage:

> isBig Nothing
"Not at all"
> isBig $ Just 0
"Just perfect"
> isBig $ Just 50
"Definitely is"

Pattern matching isn’t limited to algebraic datatypes that we have been working with so far. We can do same things with records. Below is an function used to calculate total fee when cost and customer are known. Each customer can have their own discount percentage, but in addition we’re giving 10% discount to VIP customers:

data Customer = Customer
    { customerName :: String
    , customerDiscountPct :: Double
    , vipCustomer :: Bool
    }

totalFee :: Double -> Customer -> Double
totalFee bill [email protected](Customer { vipCustomer = True }) =
    bill * 0.9 * customerDiscountPct cust

totalFee bill cust =
    bill * customerDiscountPct cust

There’s two cases of totalFee function. First one is for when passed in Customer has vipCustomer field True. Second one takes care of general case. In the first case we’re using @ to bind Customer as a whole to cust name.

Lists can be matched too. The basic idea is exactly the same:

  • (x:xs) matches a list with at least one item, x is first item, xs is rest of the items (might be an empty list)
  • (x:y:_) matches two first items in a list of at least two items, x is first, y is second, _ is rest
  • [] matches empty list
  • (x:[]) matches list of exactly one item

Underscore _ matches to everything without binding value to a name. This is useful when you don’t care about exact value, so you don’t want to give it a name. One could give it a name, but compiler will issue a warning if there are unused values in the code.

Next example is recursively counting amount if items in a list using pattern matching:

count :: [a] -> Int
count [] =
    0

count (x:xs) =
    1 + count xs

Fibonacci series is series of number which starts with 0, 1 and then rest of the numbers are sum of two previous ones: 0, 1, 1, 2, 3, 5, 8…

To calculate number in series, we can write following code (this is extremely slow way of calculating them by the way):

fibonacci :: Int -> Int
fibonacci 0 =
    0

fibonacci 1 =
    1

fibonacci n =
    fibonacci (n - 1) + fibonacci (n - 2)

Last trick in our sleeve for now is case expression. This allows us to do pattern matching inside of a function. Otherwise it works in the same way. Our fibonacci function could be defined as:

fibonacci :: Int -> Int
fibonacci n =
    case n of
        0 ->
            0

        1 ->
            1

        n ->
            fibonacci (n - 1) + fibonacci (n - 2)

Questions, comments and feedback are welcome. Best way to catch me nowadays is either email or in fediverse where I’m [email protected]


News Bewertung

Weiterlesen Weiterlesen

HPR2888: Pattern matching in Haskell

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

Pattern matching is one of those features of Haskell that immediately got me interested as it reduces amount of branching inside of functions I write. Basic idea is that if value constructors are for making data, pattern matching is for taking it apart.

First example is a function that takes a Bool and returns a respective String:

boolToString :: Bool -> String
boolToString n =
    if n
        then "True"
        else "False"

Nothing too fancy, just an if expression inside a function. We can move that if out of there though and define exactly same functionality, but with patterns:

boolToString :: Bool -> String
boolToString True =
    "True"

boolToString False =
    "False"

There’s one definition for boolToString, but two different patterns used.

Second example is bit more complex, this time we have Maybe Int that is being turned into String. Maybe has two value constructors Nothing and Just a. We have two cases for Just, specific one for when it’s Just 1 and more general one Just n that takes care of rest of the cases.

isBig :: Maybe Int -> String
isBig Nothing =
    "Not at all"

isBig (Just 1) =
    "Just perfect"

isBig (Just n) =
    if n < 10
        then "Just slightly"
        else "Definitely is"

Some example usage:

> isBig Nothing
"Not at all"
> isBig $ Just 0
"Just perfect"
> isBig $ Just 50
"Definitely is"

Pattern matching isn’t limited to algebraic datatypes that we have been working with so far. We can do same things with records. Below is an function used to calculate total fee when cost and customer are known. Each customer can have their own discount percentage, but in addition we’re giving 10% discount to VIP customers:

data Customer = Customer
    { customerName :: String
    , customerDiscountPct :: Double
    , vipCustomer :: Bool
    }

totalFee :: Double -> Customer -> Double
totalFee bill [email protected](Customer { vipCustomer = True }) =
    bill * 0.9 * customerDiscountPct cust

totalFee bill cust =
    bill * customerDiscountPct cust

There’s two cases of totalFee function. First one is for when passed in Customer has vipCustomer field True. Second one takes care of general case. In the first case we’re using @ to bind Customer as a whole to cust name.

Lists can be matched too. The basic idea is exactly the same:

  • (x:xs) matches a list with at least one item, x is first item, xs is rest of the items (might be an empty list)
  • (x:y:_) matches two first items in a list of at least two items, x is first, y is second, _ is rest
  • [] matches empty list
  • (x:[]) matches list of exactly one item

Underscore _ matches to everything without binding value to a name. This is useful when you don’t care about exact value, so you don’t want to give it a name. One could give it a name, but compiler will issue a warning if there are unused values in the code.

Next example is recursively counting amount if items in a list using pattern matching:

count :: [a] -> Int
count [] =
    0

count (x:xs) =
    1 + count xs

Fibonacci series is series of number which starts with 0, 1 and then rest of the numbers are sum of two previous ones: 0, 1, 1, 2, 3, 5, 8…

To calculate number in series, we can write following code (this is extremely slow way of calculating them by the way):

fibonacci :: Int -> Int
fibonacci 0 =
    0

fibonacci 1 =
    1

fibonacci n =
    fibonacci (n - 1) + fibonacci (n - 2)

Last trick in our sleeve for now is case expression. This allows us to do pattern matching inside of a function. Otherwise it works in the same way. Our fibonacci function could be defined as:

fibonacci :: Int -> Int
fibonacci n =
    case n of
        0 ->
            0

        1 ->
            1

        n ->
            fibonacci (n - 1) + fibonacci (n - 2)

Questions, comments and feedback are welcome. Best way to catch me nowadays is either email or in fediverse where I’m [email protected]


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

HPR2887: Stardrifter RPG Playtest Part 01

Zur Kategorie wechselnPodcasts vom | Quelle: hackerpublicradio.org Direktlink direkt öffnen

This episode begins a limited series covering the first playtest of a new role-playing game, based upon my Stardrifter series of books and short stories. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this first episode, as well as the next, we we go over the rules of the game, and discuss them in some detail.

Special thanks to my playtesters: Klaatu, Thaj, Mark (who was playing Brinn), and Brian!


News Bewertung

Weiterlesen Weiterlesen

Seitennavigation

Seite 1 von 15 Seiten (Bei Beitrag 1 - 35)
501x Beiträge in dieser Kategorie

Nächste 2 Seite | Letzte Seite

[ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ 10 ] [ 11 ]