So most people are probably used to working through a graphical user interface (GUI), which is a relatively recent way of interfacing with a computer. This is great for accessibility but also tends to scope and direct the abilities and capacities you have on your computer, as in there are only so many buttons or things you can show in a communicable way.

Terminal is a more classic way of working with a machine, and roughly speaking is the step between punch-card/magnetic tape style computing and a GUI. It is a very simple but powerful interface that lets you run basically any command on your system through a text interface. Compared to a GUI this space is more "risky" as you can do anything from anywhere, such as deleting the entire hard disc (not advised). It also means that there are no limitations to your system administration so you have access to a granular level of working.

When entering into this more "risky" space on a computer network, it is good to set some intentions and work out how to move through this space with care. As we go though these next steps getting into terminal have a think about what it means to be in this place of power/risk, and what relations you think you need to care for and form protocols for?

It can also be a great place to think about if/how your system let's you into this place of power, and what relations this empowering brings with it.

On a Mac it is already installed! So all you need to do is:

There are similar programs to terminal already installed, but not the same language (bash), so the easiest way to get going is:

Let's simply use echo to get our terminal to say HI!.

To do this use:

e.g.

Now lets see who your computer!

Show the name of the currently logged in user:

Show the name of the machine is given on the network:

Much of working on the command line involves navigating around your system without the use of a Graphical User Interface (GUI).

However, we will essentially be navigating around normal computer folder hierarchies like below:

Directory : also known as a folder

Print working directory that you are currently in:

List current directory contents:

Now to move between directories/folders we use cd like so

e.g.

The SSH protocol enables us to talk securely to our server by encrypting and authenticating all of our communication/interfacing through the network.

Traditionally tech has a metaphor of SSH as a secure hand shake protocol, but it will be great to think about what metaphor or relation we want when it comes to crossing boundaries and spaces.

Do we want to hand shake or do we think . . . would enable . . .

Again this may be a bit different on different systems, as some will have this already installed and some will need to install it.

if you are on Mac or Linux you may need to install it with:

If you are on gitbash on windows, it should be installed.

To SSH into the pi we need to know what the IP address of the pi is.

An IP address is basically the postcode/address we will find the pi at on the network.

To do this on the pi we write:

This will print out something like 192.168.0.8, and we need to save this to SSH into the pi

Now that we have the IP address, any computer on that network can request to SSH into the Pi through these commands:

eg.

You are now "logging into" the pi, so it will ask for the password here and that is . . . . . .

You should now see your terminal username change from your laptop's local user to something like:

If you want to exit out of the pi (we don't atm) type:

Hit enter. You will need to have exited the pi before setting up your ssh key.

We won't do it here as it takes a minute too long, but to do this securely we would set up a set of keys which, one private and one public, that will do the "hand shake" instead of a less secure password.

To become sudo you just need to:

And then enter the password when prompted.

Now we are all sudo we can initiate a shared session to work in together.

To do this we use:

Now we need to name our collective space. If we think back*forward in this workshop, what are the intentions, dynamics and relations we want to collectively name this space with?

Now we can say hi to one another and say cute messages in the space by:

Say something to welcome each other into this session, you may need to take turns.

As we saw even each of us writing an echo command takes a little bit of choreographing. When this gets more complicated, like writing complex configuration files, you can imagine it gets even more tricky.

So here we need to think about how we might manage collective editing. What operational metaphor might we use to describe the relationship between the person typing and the others? Who and how do we choose to type? How do we take care of every voice in that conversation?

Now we are in the right folder we can edit the file with nano which is a terminal base text editor.

To open the file with nano we do:

This will open the file in the terminal.

From here we can then add text and images using basic HTML syntax.

So for now add a message or paste in some ascii art with the help of these links:

ascii text gen

ascii image gen

Now if we return to the file online at:

https://servpub.net/ci_protocols.html

we will see our beautiful inputs.

We've finished working together and now we would like to leave our TMUX session. This is a little more complex than it might appear. Leaving a session using an 'exit' command will delete the session for others, and you will lose the record of your edits together. Instead we can either:

Close the entire terminal session window, or use Ctrl-b. This will retain the terminal session for you to use again in the future.

Our (ongoing) documentation https://github.com/In-grid-collective/servPubWiki.git

</Practice/In-Grid's In-frastructures/Collective Infrastructures/