The Quantum Computer is supposed to be a game changer that renders encryption useless. But is this true? We look at how quantum computing will affect encryption going forward, and show that we are already working on quantum-resistant encryption.

Links:

https://www.zwilnik.com/?page_id=530

http://hackerpublicradio.org/eps.php?id=1620

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

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

https://csrc.nist.gov/Projects/Post-Quantum-Cryptography

https://www.nist.gov/programs-projects/information-security-and-privacy-advisory-board-ispab

https://csrc.nist.gov/Projects/Post-Quantum-Cryptography/Round-2-Submissions

http://www.zwilnik.com/?page_id=999

Hacker Public Radio New Years Show episode 7

Welcome to the 7th Annual Hacker Public Radio New Years Show. 2018-2019

Trucking

Patrick Stewart and Bret Spiner

https://www.youtube.com/watch?v=l5zQIKeh9B4

https://www.youtube.com/watch?v=EvJ7xR4D1ZI

Self Defense

The origin of Irish coffee

Calendars

Sleep

The Pine Book

https://www.pine64.org/pinebook/

Guns

Tanks

AmazFit Bip

https://us.amazfit.com/shop/bip?variant=336750

Canes

This episode is about modeling vehicle designer that can be used to design all kinds of vehicles available in the game. It relates to episode about performing research.

Major parts

Two major parts about vehicle designer are components and chassis.

Components are modular pieces of vehicle that are assembled on chassis. They can, among other things, be things lie star sails, astrolabe navigators or long range sensor. Each component is defined by two values ComponentId and ComponentLevel. If you know these two values, you’ll be able to find out details of the component. ComponentId tells what component it is and ComponentLevel the general knowledge of it. When component is first discovered as a result of research, it’s just a prototype and as a such doesn’t function particularly well. Further research refines it and factories are able to produce higher quality components.

Full definition of component is show below:

data Component = Component

{ componentId :: ComponentId

, componentLevel :: ComponentLevel

, componentName :: ComponentName

, componentDescription :: ComponentDescription

, componentWeight :: Weight

, componentSlot :: ComponentSlot

, componentType :: [ ComponentPower ]

, componentCost :: RawResources ResourceCost

, componentChassisType :: ChassisType

}

deriving (Show, Read, Eq, Ord)

Two particularly interesting fields are componentSlot and componentType. componentSlot has type of ComponentSlot and defines what kind of slot the component occupies in chassis. As there are limited amount of slots in each chassis, designer needs to make compromises on what components to install. componentType has type of ComponentPower, which defines what component does in general. It could be sensor or provide supplies for the vehicle for example.

Technology requirements are defined by function: componentRequirements :: ComponentId -> Maybe Technology. It defines which technology unlock a given component. Part of the definition is show below. Each and every ComponentId has to be handled.

componentRequirements ShipLongRangeSensors = Just HighSensitivitySensors

componentRequirements ShipBridge = Nothing

componentRequirements VehicleWheeledMotiveSystem = Nothing

componentRequirements VehicleHoverMotiveSystem = Just HoverCrafts

...

Second major part of the designer are chassis. They’re stored in database, as I wanted a bit more flexible system than hardcoding as I did with components. Following piece of configuration is used to define database table and generated data for Haskell code. Most of the fields are probably easy enough to guess. type with type of ChassisType defines if this particular chassis is for example a land vehicle or a space ship. Various slot fields on other hand define amount of particular slots that the chassis offers.

Chassis json

name ChassisName

tonnage Weight

type ChassisType

technology Technology Maybe

armourSlots SlotAmount

innerSlots SlotAmount

outerSlots SlotAmount

sensorSlots SlotAmount

weaponSlots SlotAmount

engineSlots SlotAmount

motiveSlots SlotAmount

sailSlots SlotAmount

deriving Show Read Eq

Not all chassis are equal and some (probably pretty much every one of them) have some sort of requirements that has to be fulfilled when designing a vehicle. For example, space ships require a bridge for captain and star sails. Bawley, smallest of the working ships has room for two star sails, but requires only one of them to be installed in order to be a valid design. Flyboat on the other hand

Bitcorn is an idle farming game created with and played using Bitcoin tokens using the CounterParty protocol. I’ll walk you through how it all works, how to get started and what all that means.

In this episode we’ll walk through the basics of creating and submitting a Bitcorn collectible card to be included in the game, along with setting up a wallet so you can buy and sell them.

You can also use call forwarding to forward calls to your google voice number. Mint does not seem to stay connected all the time.

Hacker Public Radio New Years Show episode 6

Welcome to the 7th Annual Hacker Public Radio New Years Show. 2018-2019

The Makerz Podcast

https://podnutz.com/category/themakerz/

Tronxy X1

https://all3dp.com/1/tronxy-x1-3d-printer-review/

SBC talk

Apple Talk

Linux on mobile

more 3d printing talk

http://www.newmodeus.com/shop/

new years food traditions

Cats

The Last Centurion

https://www.amazon.com/Last-Centurion-John-Ringo/dp/1439132917

https://www.chewy.com/

Source for In The Morning: https://gitlab.com/jezra/in-the-morning

Bottle Framework: http://bottlepy.org

Links

https://www.bankid.com/

https://en.wikipedia.org/wiki/Swish_(payment)

Introduction

This is the sixteenth and final episode of the 'Learning Awk' series which is being produced by b-yeezi (BY) and Dave Morriss (DM).

We are using this as an opportunity to have a round-table discussion about the series, about Awk, and where we recommend the listeners should go from here. Including this one we have produced 16 episodes covering the features most likely to be used in pipelines on the command line or in simple shell and awk scripts.

Note that although the HPR site will list this episode as having a single host, in fact it has two! Plans are afoot to enhance the HPR database so we can eventually indicate this properly.

Topics Discussed

The series

Started in 2016 (first show released 2016-07-13)

Finishing in 2019

16 episodes in total

Why are we finishing the series?

We have probably reached the limit of what is useful on the command line or in shell scripts or even in manageable-sized Awk scripts

Awk shows its limitations as we go on and doesn’t compare well with more modern text processing languages

Our personal experiences with Awk

BY:

Started with sed and awk when first moving to Linux in 2011

(ongoing) Exploring and cleaning client data

(ongoing) Personal scripts when adding python or other tool would be overkill

DM:

Working with VAX/VMS in the 1980’s. No very good text processing features built-in, so Gnu Awk (and sed) was a great way to handle the data we were using to generate accounts for new students each year. Could easily spot bad records, do some data validation (for example impossible dates of birth).

Later in the late 1980’s and early 1990’s more Unix systems came on the scene running HP-UX, Ultrix, SunOS, Solaris, OSF/1, True64 Unix, and awk was very much used there.

Later still we moved to Linux; initially Fedora but later RHEL, and of course awk figured in the list of tools there as well.

What have we left out? Why?

User-defined functions are pretty clunky and hard to use

Multi-dimensional arrays: other languages do this better

Internationalization: assumes you’re writing big awk programs

The gawk debugger: quite clever but probably overkill for this series

Extensions written in C and C++: some come with gawk and look quite good, but this subject is out of scope

What to use as an alternative to Awk?

DM moved from gawk to Perl (version 4) in the 1980’s and later to Perl version 5. This might have engendered an awky, Bashy mindset that’s hard to shake off. Not the recommended place to start these days.

BY moved from gawk to Python and R for large projects. For interactive Bashy exploration, moved to XSV, q, and csv-kit for most use cases.

These tools have built-in convenience features, like accounting for headers, data types, and file encodings

What’s next?

It is planned to turn the notes for this series into a combined document which will be available on the HPR site and

Some general basic knowledge of fire fighting. Also an invitation to ask questions in the comments.