This workshop takes on fragile knowledge (knowledge without real understanding, which makes it hard to use for deriving concepts or solving problems) of the Unix/Networking space. This is the description I use for it:
Learn about Unix and the Internet in one hour! I found that, unlike for web frameworks or machine learning, there aren't really any good, quick learning resources for networking and operating systems that give you an overview and some tools to get started. Hence this workshop. We'll cover just enough to make you more comfortable with dealing with the internet, even if (and especially if) you never actually plan to do any lower-level coding yourself.
You should attend if:
- you heard of/worked with concepts like http/tcp/port/socket/posix/etc a hundred times, but don't quite know what they mean
- you think that lower-level OS/networking stuff is intimidating
You should also attend if:
- you want to learn more about how your *nix operating system works (be it OSX, Linux, or something else)
- you have written an application that interacts with the internet in a high-level language like Python or Ruby, and want to know how it works under the hood
- you want to learn about lower-level OS/networking stuff, but don't know where to start
(We will explore what happens between the tcp and http layers using tools like netstat/lsof/telnet/ifconfig and some Python).
- a projector
- a whiteboard
- an internet connection to live-code and run tools
This presentation uses remarkjs, a tool that renders markdown slides in the browser. Due to the current limitations, running it requires hosting your files using a web server:
# change into the presentation directory
cd presentation-directory
# run a web server that serves the files in the directory
python -m SimpleHTTPServer 8000
# access the presentation at http://localhost:8000/remark-presentation.html
# access the cheatsheet at http://localhost:8000/remark-cheatsheet.html
Fragile knowledge is helped by plunking slide after slide of bullet points onto your audience. Fragile knowledge can be combatted by telling a coherent story that ties all that knowledge together into a relevant whole, and by giving your audience tools that can be used to investigate these topics.
Adapt the story to your audience. If they have fragile knowledge of IP addresses, spend more time on tools showing IPs, how a local IP cannot be accessed from the public internet, what the router is doing. If they have done some C programming but have fragile knowledge about the kernel, talk about how the kernel keeps a record of processes and ports. Etc.
Substitute those topics you're not excited about for something that makes you excited. Or, if they're too important to be left out, find an angle (maybe a tool, or new knowledge) that will make them exciting to you again. Excitement is the best transmitter of non-fragile knowledge, and the best guard against presenting information in a non-relevant way.
- a handful of slides
- a tools cheat sheet
- extensive teaching notes on story flow and presentation
- The presentation/workshop takes about an hour if you leave out the python sockets server slide and exercise #4 slide, or about an hour and a half if you include writing a simple python sockets server and doing exercise #4.
- I like to put the story points I'm going through on index cards to both be able to talk freely and not get off track.
- The teaching notes give pointers on when it's useful to use the whiteboard or to live-code.
- This workshop has a major flaw - it doesn't integrate security knowledge. If you'll be using it before it's updated, make sure to say a couple words about security with each topic.
- Obviously the notes are simplified. Eg. "the IP packet has a header with an IP, and a payload" should read "has a header with an IP + some other stuff". Etc.
- System Call Interface and glibc by Shmuel Csaba Otto Traian / CC-BY-SA-3.0.
- Rendered with remarkjs.
- Using the solarized color palette.
