Welcome to INLS161!

Wednesday, 24 August 2016

This is a course about pushing our boundaries and learning new things. It is also about learning new ways of doing things that we might already know how to do. Some of the topics and skills covered by the course might be old hat for some of you. Others may not have ever heard of some of these things.

Course Vitals

Course Topics

This course consists of six main topics, each of which has a corresponding assignment:

Without further ado, on to the first topic, Basics.

A Study in Contrasts: Techifying the Gettysburg Address

You'll develop a lot of skills in this course, learn how to do entirely new things, and learn new, more powerful ways to do things you may already know how to do.
Why is learning a more powerful way to do something powerful? Let's look at an example.

Assignment #6 is an HTML multimedia presentation that you will write and present, using a number of the skills we'll learn this semester. Why add technology to a presentation?

The Gettysburg Address, widely regarded as one of the great 'presentations' in American history, was given without technological aids. And not every presentation needs technology.

But what if Lincoln had used technology in his speech? Here are two contrasting visions:

By the end of this class you'll have a more powerful option to choose for each of the course topics. You'll be able to use these in other classes, in your professional career, or just for fun.

Tools

Choosing the right tool for the job is super important. In this class we'll be using professional grade tools that should end up on your resume once you've mastered them.

GitHub

GitHub

To get us started, we will be using GitHub as a repository for our output.

GitHub will also help us learn about version control and the importance of keeping your versions in order. This should appeal to budding programmers, researchers and archivists equally.

Cloud9

Cloud9

Following that, we will use Cloud9 to learn about the command line, to control a server remotely and to do our web development tasks.

Cloud9 is a web-based integrated development environment (IDE). It highlights syntax for a number of different languages and makes it easy to get to your code wherever you are. It also provides built-in access to your very own Linux server, which, as we'll see, is a very powerful standardized tool that you'll learn to use in various ways.

In today's session, we are going to make sure that everyone is set up on GitHub and add everyone to an GitHub organization for this class. We will also set up Cloud9 and make sure that everyone can log in and set up a Dev Box where you will be able to do some of your work.

Plaintext

We will approach all of the tasks for this class starting with plaintext. A note on plaintext: Forget what you think you know about text documents. Word documents, Google docs and the like have all sorts of cruft in them in addition to the text you type. Plaintext means a file that has nothing but ones and zeros indicating text characters in it. It's what all programming languages, websites, and many technical papers like journal articles are written in, mainly because what you see is very close to what the computer sees. That's power! By the end of this class you'll love plaintext as much as I do. This means no GUIs to get in the way of our content or design. It helps us see what the computer sees when we write text. And, as explained below, it offers unmatched power and flexibility.

We will learn how to run on a command line interface (CLI) and how to do some basic scripting to automate our work.

Try new things

This is a course about trying new things and learning in non-linear ways. If you are used to doing something one way, then branch out and do it in another way. This might seem difficult at first, but it will only benefit you in the long run. By increasing your flexibility and allowing you to swap different tools in and out of your toolchain as needed, you will develop a very marketable technical skillset.

Next we'll take a look at some different ways of doing things and what that means for us.

This is the meat of today's lecture.

Flexibility == technological skill

As previously mentioned in the notes, this class is about challenging your boundaries with basic technological tools. This will mean sometimes learning what seems to be a really complicated way of doing something that seems like it should be simple.

But things are not always as they appear. Like upgrading from crayons to paint, the initial complexity of new tools is far outweighed by the power they give you.

You may think that it is simpler to create a webpage using some specially-designed interface for web design or, worse, creating a document in MSWord and then either copying and pasting that your work into a what-you-see-is-what-you-get (WYSIWYG) editor or exporting to HTML. You can do this, but if you want to use your markup later on or understand what is happening (as we do in this class), it is not a good option. You're stuck using crayon.

Let's look at a couple different ways of making a PDF as an illustration of this.

One toolchain looks like this:

LibreOffice Writer (software) > ODT (file format) > Export as PDF (file format)

Another looks like tihs:

Markdown (plaintext markup) > Pandoc (software) > LaTeX (software) > PDF (file format)

The difference here is the way that the SOURCE of the files are conceived. The source for the first option is wrapped up in the interface somewhere. We can't see it. The source for the second option is the original plaintext file using markup to tell the interpreter what to do with it.

Why is this second approach advantageous?

Let's look at a second usage scenario. Let's say that I want to have the same document that I put into PDF, but as a web page also.

From LibreOffice, I have to export HTML and then upload it to a web server. Fine.

If I start with Markdown, however, my toolchain looks like this:

Markdown > Pandoc > HTML

What is better yet is that since the tools in this scenario rely on marked-up plaintext and commands that can be executed without a graphical user interface (GUI), I can create and upload the documents from my trust Cloud9 account rather than having to upload them after working on them locally.

In addition, instead of clicking through a bunch of menus at human speed, I can create a powerful one-line command, or a script of several commands, to do the whole task at computer speed whenever I want. This is kinda of like the difference between a kitchen that I have to operate manually and the Replicator from Star Trek The Next Generation. A note on replicators: This is optional of course, but why not dig in and learn a little about what it was like to be a nerd in 1996? Here's a Klingon using a replicator to get you started:

For the record, though I love Star Trek The Next Generation like a crazy uncle, it's clearly surpassed by the original series, the J.J. Abrams films, and all of Start Wars. Yes, including the first three. Only Voyager and that one with the Feringi dude on the boring starbase are worse. Karma points for anyone who brings me Tea. Earl Grey. Hot.

So, by using plaintext, you get a powerful, flexible way of making your content into almost any format, and it's easy to make the computer do all the boring work for you, at computer speeds. This frees you up to think ponderously at human speed about what you want to write, the meaning of life, etc.

There are easy ways to do everything, and there are hard ways to do everything. Neither are ever going to be the right way all the time. The method that you use to complete a task has to depend on the context of the task. The right way will fall somewhere in the middle or be an amalgam of both.

This all boils down to Compute smart, not hard. The skills you will learn in this class will help you do things efficiently with computers and lay a great foundation for using computers well. Regardless of whether you choose to go on to learn to program in other courses at SILS or elsewhere, you'll have an ability to make computers do boring work for you efficiently.

We'll talk more in the next few sessions about operating on a system using the command line for giving instructions and running programs.

For the next session:

I would like you to have a look at the Bill Shotts' "Learning the Shell."Read: Shotts, William, Jr. “Learning the Shell.” LinuxCommand.org. http://linuxcommand.org/lc3_learning_the_shell.php. Go through each of the steps in the contents listed on that page and try out the commands in your Cloud9 DevBox interface that we set up. This should take at least an hour and will be time well spent, especially if this sort of thing is new to you. We'll go over portions of this reading over the next few class periods, and I'll answer any questions you have.

I would also like you to read Tristan Harris' blog postRead: Harris, Tristan. “How Technology Hijacks People’s Minds — from a Magician and Google’s Design Ethicist.” Medium. Last modified May 18, 2016. https://medium.com/swlh/how-technology-hijacks-peoples-minds-from-a-magician-and-google-s-design-ethicist-56d62ef5edf3. about how design choices in interfaces affect how we think and interact.

Please come with one or two observations or questions from the readings to kick off the class.


Welcome to INLS161! - August 24, 2016 -