Annotated Tuesday 19 May, 2020 by John NaughtonJohn Naughton (Memex 1.1)

Interestingly, I’ve found that Kindle is useful in this respect. I buy Kindle versions of books that I need for work, and highlight passages and bookmark pages as I go. And when I’ve finished the software obligingly has a collection of all the passages I’ve highlighted. 

John, you should spend a minute or two to learn about Hypothes.is as an online tool for doing this. It’s a free account or you can self-host the software yourself if you like. There are also functionalities to have public, private, or group annotations.

I often pull my own annotations to my personal website similar to your own Memex and publish them there (example: https://boffosocko.com/kind/annotation/)

Incidentally you can also annotate documents stored locally on your computer, but viewed through a browser as well as collaboratively annotating with others.

Read Fall Scenario #13: A HyFlex Model (Inside Higher Ed)
The challenge of flexibility.

It’s important to note that the goal of HyFlex is two make both the online and in-person experiences equal. 

There are some pieces of this that immediately make me think that this model is more of a sort of “separate, but equal” sort of modality. Significant resources will need to go toward the equality piece and even then it is likely to fall short from a social perspective.

Annotated on May 21, 2020 at 01:27PM

Finally, the best HyFlex classrooms have someone assisting the faculty member. 

This is the understatement of the year. Faculty members will require extensive training and LOTS of assistance. This assistance SHOULD NOT come from student assistants, graduate students (who are likely to be heavily undertrained), or other “free” sources.

Annotated on May 21, 2020 at 01:35PM

These assistants could also be work-study students who are assigned a particular classroom (or digital space) or they might be volunteers from class who are given credit for assisting in the delivery of the course. 

And of course, the first pivot (even in the same paragraph!) is exactly to these “free” or cheap sources which are likely to be overlooked and undertrained.

If a school is going to do this they need to take it seriously and actually give it professional resources.

Annotated on May 21, 2020 at 01:38PM

Incidentally there is some pre-existing research about the measurable fairness of court proceedings being held online that would tend to negate the equality that might be dispensed in online courseware.

See https://www.wnycstudios.org/podcasts/otm/episodes/are-online-courts-less-fair-on-the-media for some references. 
Annotated on May 21, 2020 at 02:42PM

This fall needs to be different. We need to ask students to be part of the solution of keeping learning flourishing in the fall. This includes asking them to help manage the class if it has a virtual component. 

This is moving education in exactly the WRONG direction. Students are already ill-prepared to do the actual work and studying of education, now we’re going to try to extract extra efficiency out of the system by asking them to essential teach themselves on top of it? This statement seems like the kind of thing a technology CEO would pitch higher education on as a means of monetizing something over which they had no control solely to extract value for their own company.

If we’re going to go this far, why not just re-institute slavery?

Annotated on May 21, 2020 at 02:46PM

Webmention for TiddlyWiki to enable website to website notifications and communication

What is a Webmention?

Webmention is a relatively recent web standard (or W3C recommendation) that allows notifications when one website mentions a URL on another website. Think of it like @mentions on social platforms, but instead of just working within a particular website from one account to another, they work across websites. Your website can now @mention my website!

For those who are interested in delving deeper into the idea and its implications, I’ve written a primer in the past : Webmentions: Enabling Better Communication on the Internet.

The goal is for other websites to be able to reference content in my TiddlyWiki website, and if those websites support sending the notifications as either webmentions (or the older pingbacks), I’ll get a notification that my content was referenced elsewhere on the web. This is just the beginning of allowing two way communication between websites.

My exploration today is how to quickly get these up and running on a public TiddlyWiki instance. The public part is important because webmentions won’t work for non-public URLs which includes private TiddlyWikis. If you’re wondering how to self-host a TiddlyWiki on your own domain, I’ve recently written up a tutorial for doing just that. At the end of this article, I’ll make a few notes about how one might use webmentions, particularly in a TiddlyWiki ecosystem.

I’ll start out by saying that writing a full JavaScript implementation of the Webmention spec is beyond my capabilities presently, but it could be something that TiddlyWiki core might implement in the future. (Maybe something like Lazymention which is written in node.js might be leveraged?)

Here I’m going to focus on using a third party service to do all of the heavy lifting and code our behalf. It’s relatively common, especially in the static website space, for websites to rely on third party or publisher services to either send or receive Webmentions on their behalf. Given my current knowledge of TiddlyWiki and how its internals work and my knowledge of Webmention services, I thought it would be quickest and easiest to look at using the Webmention.io service to handle receiving these @mentions from other sites on my behalf.

While this article may seem long, I’m hoping it’s detailed enough for those who are code averse to follow the recipe and do this themselves. If you can create a Tiddler, cut and paste some text, and follow the tutorial you won’t need to know anything about code. I did the entire thing myself in about five minutes from start to finish.

Receiving Webmention notifications for your TiddlyWiki

As a quick overview, we’re going to cut and paste a few lines of code into a special tiddler of our TiddlyWiki based website. This will allow us to do two things:

  1. Log into Webmention.io to create an account
  2. Allow other sites that send webmentions to us to find an endpoint on our TiddlyWiki website that accepts them on our behalf.

We’ll then rely on the Webmention.io dashboard to show us our notifications or received webmentions.

Logging into Webmention.io

Webmention.io requires you to log in with your domain name/URL and relies on you being able to authenticate yourself using it. Since I’m not aware of an IndieAuth or equivalent mechanism for using TiddlyWiki to log into Webmention.io, the quickest method to accomplish this is to rely on RelMeAuth using IndieAuth.com to log into Webmention.io using either a Twitter or GitHub account. From a non-technical perspective, we’ll be using either our Twitter or GitHub account and it’s OAuth2 security to log into the service.

First we want to put a link to our public TiddlyWiki website into the website field on either Twitter or GitHub using the profile settings of one of those services. Here’s what mine looks like on GitHub:

Screenshot of my GitHub accounts details featuring a link to my website

Next we want to place a corresponding link to the relevant service into the <head> of our TiddlyWiki site using one (it’s okay to use both) of the the following lines of code:

<link rel="me" href="https://twitter.com/username" />
<link rel="me" href="https://github.com/username" />

where you will replace the username in these links with the respective usernames of your accounts. (I’ll note that you don’t need to do this for both accounts, you can use either Twitter or GitHub.)

To place these lines into the appropriate location on your TiddlyWiki, you’ll want to create a tiddler with a name like $:/plugins/indieweb/core/rawMarkup and the tag $:/tags/RawMarkup.

Then cut and paste one or both of these links as appropriate into this tiddler and save it (and your TiddlyWiki).

You should now be able to go to webmention.io and enter the URL for your TiddlyWiki into the web sign in box and click “sign in”. The service will parse your website’s page, find the link to either Twitter or GitHub and present you with the appropriate sign in button for one or both of those services. Click on the button for your chosen service. IndieAuth.com will then take you to that service to log into it, or, if you’re already logged in, it will take you back to webmention.io to your new account.

Creating your Webmention endpoint

Within webmention.io you can now go to the “settings” page which will give you two more links which are your webmention and pingback endpoints. They will look something like this:

<link rel="webmention" href="https://webmention.io/example.com/webmention" />
<link rel="pingback" href="https://webmention.io/example.com/xmlrpc" />

where example.com will be replaced with the URL for your website.

Now you should cut and paste these two <link>s into the same tiddler you created above: $:/plugins/indieweb/core/rawMarkup. Now save the Tiddler and your TiddlyWiki. (Be sure to leave the previous links in case you need to log back into webmention.io in the future.)

You’re done!

That hopefully wasn’t too hard.

But what does this do? When another website links to your website and sends you a notification, the code on your page will delegate the receipt of the webmention to webmention.io which will verify that the sending site has your URL on a publicly viewable page (this helps to cut down on spam problems that pingbacks used to have). It will then store the notification for you.

If you need a reminder to check them occasionally, maybe you could add a Tiddler with the link to your dashboard to appear on your wiki when you open it next.

Perhaps in a future tutorial I’ll delve into the specifics of actually showing these mentions directly within your TiddlyWiki on the Tiddlers to which they relate.

Optional Webmention badge

Some may notice that I’ve put a small Webmention badge into the footer of my TiddlyWiki site to visually indicate to human readers that the site accepts webmentions. You can optionally do this for fun if you’d like.

Sending Webmentions with TiddlyWiki

Sending Webmentions seems to be an issue as the fragment-based URLs that TiddlyWiki uses as permalinks using JavaScript seem to cause an issue with many receivers. They apparently have problems resolving and parsing pages due to js;dr related issues. I would send webmentions manually, but most receivers I’m aware of have this js;dr problem. I’m not sure if there is an easy way around this issue.

Hyperchats, Wikis, and Open Educational Resources

What’s interesting about supporting Webmention, particularly from a TiddlyWiki perspective, is that if my TiddlyWiki is notified of mentions of it from outside sources, I can quickly cut and paste those responses directly into my Wiki pages in a pseudo-comment section similar to the comments section on this post which could serve as a model. If those mentions of a particular Tiddler are from other TiddlyWikis, I could also choose to drag-and-drop (or import) them into my TiddlyWiki!

If I want to go a step further, I could transclude those imported Tiddlers into the Tiddler that they’re in reference to. Perhaps I might do this under a heading of “@mentions” or perhaps “Comments” and suddenly I’ve got a way of displaying two-way conversations on my own TiddlyWiki site.

As is mentioned in Kicks Condor’s post about Hyperchat Modality, one could potentially use custom theming information (cleverly named “whostyles” in that post) from imported Tiddlers (or themes from other platforms) to identify the web identities of the sites they’re received from. I’ll also mention Kicks’ post about Hypertexting which is related and forms an interesting melange of websites, blogs, wikis, and hypertext of all kinds to form a more interesting web medium.

For the broader information collecting and building or academic communities (and here I can’t help thinking about the Open Educational Resources space that uses Creative Commons licensing to build their teaching resources), one could use these webmentions as a means of notifying sites that their content has been used, changed, or updated (typically those using Creative Commons will credit their source using a link). Then the receiver of the notification could optionally add to or change their version or even just collect the changes. This becomes particularly useful when the Tiddlers can be easily dragged and dropped between TiddyWikis!

As an explicit example, imagine a professor who wanted to build a textbook anthology, but who could do so by dragging and dropping a variety of Tiddlers from one site to another to create a quick textbook or reader for their students. This idea is particularly exciting to me when combined with the idea behind TW5-powered ebooks!

What could you imagine doing with webmention notifications on your TiddlyWiki site?

Self-hosting TiddlyWiki with GitHub Pages

TiddlyWiki is most often used as a private wiki for personal note taking and creating private journals.

Because it is a single text file usually named index.html written in HTML, CSS and some JavaScript, I thought it would make an ideal candidate for a simple-to-use personal website that can be hosted on one’s own domain. As a researcher who appreciates the IndieWeb and Domain of One’s Own philosophies and uses my personal website as a commonplace book for both work and personal reasons, how could I resist?

TiddlyWiki

TiddlyWiki is easy to use, highly flexible, modifiable, and can be easily copied, backed up, and shared. There’s an active community of users and developers for the platform which dates back to 2004. There are a variety of examples and documentation online and plugins are literally as simple as dragging and dropping some files from one source directly into your own Wiki. For those interested in the OER movement, individual Tiddlers (TiddlyWiki’s name for cards or discrete entries within the wiki) can be easily dragged and dropped from other TiddlyWikis to copy them!

There are some useful instructions for hosting it almost everywhere–except on one’s own domain name.

The few easy options I’ve found for hosting a TiddlyWiki publicly online as a website were rely on someone else’s service as a subdomain. As much as I like the idea of TiddlySpot I really wanted to use my own domain name (not to mention that it’s non-obvious how to host a newer TiddlyWiki version 5 (TW5) instance there). I’d also seen TiddlySpace shut down a few years ago and didn’t want to deal with that potentiality—though I will admit that exporting would be as simple as downloading and moving a single file!

So after a month or so at tinkering around at several complicated solutions that always seemed beyond my grasp, I went back to IndieWeb basics. What is their recommendation for the easiest way to get a website up and running? The fact that an empty TiddlyWiki file is named index.html gave me my answer: set up a GitHub Pages-based website and simply connect it to my domain!

However, as simple as this pathway may seem to some, I thought I’d briefly document the process I took so others can do the same for themselves.

First I’ll presume you’ve got a domain name and a host that will allow you to change the CNAME for where your domain name is pointed. (If you don’t, check out https://indieweb.org/personal-domain for details.)

In short, you’re going to upload a single file to your GitHub account and then point your domain name at it.

The idea of GitHub may scare a lot of people, but you won’t need to use git, know any git commands, or even know how git works since I’ll describe steps that entirely use the graphical user interface and don’t come anywhere near using the command line or any complicated GitHub applications. It’ll be as easy as dragging and dropping.

Let’s start!

Step-by-Step Tutorial

Get TiddlyWiki

  • Go to https://tiddlywiki.com/ and click on the “Download Empty” button on their homepage. This will allow you to save a file called index.html to a convenient place on your computer.
  • This one file is the entirety of your future website! Guard it well.

GitHub

  • If you don’t already have one, create an account at https://github.com/
    • You’ll use this account and their free GitHub Pages service to host your website for free as long as the project folder (also known as a repository) you are hosting is public.
  • At GitHub create a new repository.
    • Name it username.github.io, where username is your username (or organization name if you’re doing it for your organization) on GitHub.
    • Give your repository an optional descriptive name. I named mine “A TiddlyWiki commonplace book”
    • Choose the “Public” option, otherwise no one will be able to visit your new website.
    • Click “Create Repository”
  • Upload your TiddlyWiki to your new repository
    • In the Quick Set Up box click on the link for “uploading an existing file”.
    • On the subsequent page you can either drag and drop the empty TiddlyWiki index.html file you saved on your computer or you can click “choose your files” to find and upload the file.
    • If you like, you can optionally add any additional README, License, or gitignore files as necessary. If you don’t know what these are you can safely skip them or revisit doing this later.
    • Under “Commit changes” give your upload a short title; the suggested “Add files via upload” is fine. You can add an optional extended description if you like.
    • Click on the “Commit Changes” button.
      • P.S.: If you haven’t done so before you’ve just made your first Git commit. Congratulations!!
    • Your https://github.com/username/username.github.io repository folder should now be ready and have your index.html file in it.

Setting up your domain

Setting up your website

  • It may take a while for the DNS system to propagate the changes from your host, but you should be able to visit your website and see your empty TiddlyWiki online. Congrations! You’ve got a new website.
  • You’ll notice in the TiddlyWiki documentation that the first rule of TiddlyWiki is to always save or back up your wiki!
    • (The second rule, in true Fight Club fashion, is–let’s say it together–to always save or back up your wiki!)
    • Since our wiki is on GitHub, we’ll want to use the Save to a Git Service instructions. Once set up, the changes to our TiddlyWiki should automatically self-save (this can be changed within your wiki’s Control Panel too) or they can be saved manually using the TiddlyWiki checkmark save functionality.
    • I’ll note that you can presently use your GitHub password in these settings, but this isn’t quite as secure as generating a custom token (or password), and sometime in late 2020, GitHub won’t allow you to use your basic account password this way, so you may as well set up the personal access token now.
  • Setting up Personal Access Tokens
    • You will need a Personal Access Token (essentially a password that will be specific to your TiddlyWiki account) in order to save your TiddlyWiki file.
    • On GitHub, click on your user icon, select “Settings”, then “Developer Settings”
    • Next click on the “Personal Access Tokens” tab and then click “Generate new token”
    • Give your token a descriptive name like “TiddlyWiki”
    • Under scopes, select “repo” (and all of its sub-scopes)
    • Click the “Generate Token” button at the bottom of the page.
    • Once created, immediately copy this string somewhere safe since navigating away from the page will not allow you to recover it. (If you do, you’ll need to regenerate a new token.)
    • Finally copy the text of your token into the Tiddler noted above in place of your password. There’s no explicit save button, just ‘X’ out of the settings control panel and click your TiddlyWiki’s main save button.
    • Your token value should be stored in browser local storage.
    • Now you can edit any Tiddler and save it.
      • After edits to your wiki, you’ll see that the checkmark icon on the page is red (depending on your theme), indicating changes to save. You can click on it to force a save.
      • I’ve found it convenient to wait for the TiddlyWiki to schedule the save on its own, however, make sure you’ve saved any changes you want before closing your browser tab.
      • Sometimes saves aren’t always successful and you’ll see error warnings, but usually they’ll clear themselves up on subsequent auto saves.
      • If necessary, you can visit your GitHub repository for your wiki and it will indicate the interval of time since the last save.

We’re done!

  • Everything after this you may be able to either handle yourself by poking around your new wiki or you can find lots of help in the two Google Groups listed above or by searching around online, in fora, or even step-by-step videos on YouTube.
  • If you’ve done this as part of the IndieWeb or A Domain of One’s Own, be sure to log yourself into the IndieWeb wiki and add yourself to the examples on their TiddlyWiki page where you might also find some other useful ideas.
  • If you like, you can delve deeper into GitHub and use one of their apps or command line functionality to regularly back up your website to your desktop, or you can make branches of your site on your local computer and then push those changes up to the cloud.
  • If you find problems or encounter issues, feel free to drop me a line or catch me or others in the IndieWeb chat.
Read How to style RSS feed by Hsiaoming YangHsiaoming Yang (Just lepture)
Let's create a beautiful RSS feed UI for human before its dead in next year again.
This seems like quite a clever way of adding some human readable styling to RSS feeds. While it seems like yet another side-file, it could be a useful one. I think if I were implementing it I’d also want to include a SubToMe universal follow button on it as well
Read The 100 Worst Ed-Tech Debacles of the Decade by Audrey Watters (Hack Education)

For the past ten years, I have written a lengthy year-end series, documenting some of the dominant narratives and trends in education technology. I think it is worthwhile, as the decade draws to a close, to review those stories and to see how much (or how little) things have changed. You can read the series here: 2010201120122013201420152016201720182019.

I thought for a good long while about how best to summarize this decade, and inspired by the folks at The Verge, who published a list of “The 84 biggest flops, fails, and dead dreams of the decade in tech,” I decided to do something similar: chronicle for you a decade of ed-tech failures and fuck-ups and flawed ideas.

I started reading this over the holidays when Audrey released it. It took me four sittings to make it all the way through (in great part because it’s so depressing). I’ve finally picked it back up today to wallow through the last twenty on the list. 

I’m hoping that at least a few people pick up the thread she’s always trying to show us and figure out a better way forward. The information theorist in me says that every student has only so much bandwidth and there’s an analogy to the Shannon Limit for how much information one can cram into a person. I’ve been a fan of Cesar Hidalgo’s idea of a personbyte (a word for the limit of information one can put into a person) and the fact that people need to collaborate to produce things bigger and greater than themselves. What is it going to take to get everyone else to understand?

If anything, the only way I suspect we’ll be able to better teach and have students retain information is to use some of the most ancient memory techniques from indigenous cultures rather than technologizing our way out of the perceived problem.

Annotations/Highlights

(only a small portion since HackedEducation doesn’t fit into my usual workflow)

In his review of Nick Srnicek’s book Platform CapitalismJohn Hermann writes,

Platforms are, in a sense, capitalism distilled to its essence. They are proudly experimental and maximally consequential, prone to creating externalities and especially disinclined to address or even acknowledge what happens beyond their rising walls. And accordingly, platforms are the underlying trend that ties together popular narratives about technology and the economy in general. Platforms provide the substructure for the “gig economy” and the “sharing economy”; they’re the economic engine of social media; they’re the architecture of the “attention economy” and the inspiration for claims about the “end of ownership.”

Annotated on March 08, 2020 at 02:35PM

It isn’t just the use of student data to fuel Google’s business that’s a problem; it’s the use of teachers as marketers and testers. “It’s a private company very creatively using public resources — in this instance, teachers’ time and expertise — to build new markets at low cost,” UCLA professor Patricia Burch told The New York Times in 2017 as part of its lengthy investigation into “How Google Took Over the Classroom.”

Annotated on March 08, 2020 at 03:04PM

Followed Norman Walsh (so.nwalsh.com)

Norman Walsh headshot Structured markup geek. Programmer. Photographer. Author. XML. DocBook. XProc. XSLT. XQuery.
I am currently an employee of MarkLogic Corporation where I’m an engineer. I work out of my home in Austin, TX. Previously, I was employed by Sun Microsystems, Arbortext, and O’Reilly Media (then O’Reilly & Associates).

Listened to Microcast #082 – Nodenoggin by Doug Belshaw from Thought Schrapnel

This week, I’ve been delighted to be able to catch up with Adam Procter, academic, games designer, open advocate, and long-time supporter of Thought Shrapnel.

We discussed everything from the IndieWeb to his PhD project, with relevant links below!

Show notes

My IndieWebCamp Austin 2020 Project: The Who, What, Why, How, When, Where of IndieWeb

Yesterday, the ever-thoughtful Jean MacDonald led a conversational session at IndieWebCamp Austin on Explaining the IndieWeb (video of the session).

The session highlights one of the communities’ ongoing struggles is to help to define itself simply to a tremendously large group of people from different backgrounds and wealths of experiences. The community has build a massive Wiki of resources, tools, ideas, definitions, and brainstorming that can at times seem impenetrable to the newcomer. Simplifying and breaking things down into smaller constituent parts may be a helpful exercise.

Toward that end, as another potential entry-point to the community, I’ve created a page called IndieWeb Questions that aggregates and attempts to quickly answer the common Who, What, Why, How, When, Where questions about the IndieWeb and provide a range of low-level jumping off points to highlight further information, before attempting to provide more specific technical information.

I’d like to invite those who participated in the session yesterday, others in the community, and especially those who may be new to the community to contribute to the page or point out parts that they may find difficult to understand or confusing. If you can’t log into the wiki to do so (yet), feel free to join the chat and add your commentary there or post on your site of choice.

I’d also specifically challenge people to write essays (preferably on their own sites) about what the IndieWeb is to them, how they define it personally, and what they’d like to see in the future and post it in the Articles section of this new page. A diversity of perspectives here may be helpful in welcoming the broadest diversity of people into the community in the future.

As ever, I expect the idea of IndieWeb to mean something slightly different to everyone the same way that they’ll approach it with different technical abilities and personal preferences. Hopefully in the end, the playing field will level out for everyone and we’ll all just think of it as “using and being on the web”.

Bookmarked Gopher: When Adversarial Interoperability Burrowed Under the Gatekeepers' Fortresses by Cory DoctorowCory Doctorow (Electronic Frontier Foundation)

The Gopher story is a perfect case history for Adversarial Interoperability. The pre-Gopher information landscape was dominated by companies, departments, and individuals who were disinterested in giving users control over their own computing experience and who viewed computing as something that took place in a shared lab space, not in your home or dorm room.

Rather than pursuing an argument with these self-appointed Lords of Computing, the Gopher team simply went around them, interconnecting to their services without asking for permission. They didn't take data they weren't supposed to have—but they did make it much easier for the services' nominal users to actually access them.

Paul Linder‘s retweet of a post by Cory Doctorow ()
Bookmarked Gods and Robots: Myths, Machines, and Ancient Dreams of Technology by Adrienne MayorAdrienne Mayor (Princeton University Press)

The fascinating untold story of how the ancients imagined robots and other forms of artificial life—and even invented real automated machines

The first robot to walk the earth was a bronze giant called Talos. This wondrous machine was created not by MIT Robotics Lab, but by Hephaestus, the Greek god of invention. More than 2,500 years ago, long before medieval automata, and centuries before technology made self-moving devices possible, Greek mythology was exploring ideas about creating artificial life—and grappling with still-unresolved ethical concerns about biotechne, “life through craft.” In this compelling, richly illustrated book, Adrienne Mayor tells the fascinating story of how ancient Greek, Roman, Indian, and Chinese myths envisioned artificial life, automata, self-moving devices, and human enhancements—and how these visions relate to and reflect the ancient invention of real animated machines.

As early as Homer, Greeks were imagining robotic servants, animated statues, and even ancient versions of Artificial Intelligence, while in Indian legend, Buddha’s precious relics were defended by robot warriors copied from Greco-Roman designs for real automata. Mythic automata appear in tales about Jason and the Argonauts, Medea, Daedalus, Prometheus, and Pandora, and many of these machines are described as being built with the same materials and methods that human artisans used to make tools and statues. And, indeed, many sophisticated animated devices were actually built in antiquity, reaching a climax with the creation of a host of automata in the ancient city of learning, Alexandria, the original Silicon Valley.

A groundbreaking account of the earliest expressions of the timeless impulse to create artificial life, Gods and Robots reveals how some of today’s most advanced innovations in robotics and AI were foreshadowed in ancient myth—and how science has always been driven by imagination. This is mythology for the age of AI.

Bookcover of Gods and Robots

Sean Carroll Mindscape Episode 40: Adrienne Mayor on Gods and Robots in Ancient Mythology (#)
Listened to Episode 40: Adrienne Mayor on Gods and Robots in Ancient Mythology from Sean Carroll's Mindscape

The modern world is full of technology, and also with anxiety about technology. We worry about robot uprisings and artificial intelligence taking over, and we contemplate what it would mean for a computer to be conscious or truly human. It should probably come as no surprise that these ideas aren’t new to modern society — they go way back, at least to the stories and mythologies of ancient Greece. Today’s guest, Adrienne Mayor, is a folklorist and historian of science, whose recent work has been on robots and artificial humans in ancient mythology. From the bronze warrior Talos to the evil fembot Pandora, mythology is rife with stories of artificial beings. It’s both fun and useful to think about our contemporary concerns in light of these ancient tales.

Adrienne Mayor is a Research Scholar Classics and History and Philosophy of Science at Stanford University. She is also a Berggruen Fellow at Stanford’s Center for Advanced Study in the Behavioral Sciences. Her work has encompasses fossil traditions in classical antiquity and Native America, the origins of biological weapons, and the historical precursors of the stories of Amazon warriors. In 2009 she was a finalist for the National Book Award.

I’d never considered it before, but I’m curious if the idea of the bolt on Talos’ leg bears any influence on the bolts frequently seen on Frankenstein’s monster? Naturally they would seem to be there as a means of charging or animating him, but did they have an powers beyond that? Or was he, once jump-started, to run indefinitely? Bryan Alexander recently called out his diet (of apples and nuts), so presumably once he was brought to life, he was able to live the same way as a human.