> Understand shells such as sh, csh, ksh, tcsh, bash, zsh.
I was taught csh as an undergrad. A complete waste of time, in my opinion, akin to teaching BCPL rather than C. Just teach bash, and perhaps sh. To my knowledge, just about nobody writes scripts in csh, ksh, tcsh, or zsh. You use bash for portability across Unix systems, sh for even better portability across Unix systems, or you use a modern scripting language like Python3.
Students may benefit from learning zsh for interactive use, but I don't think there's enough benefit there to justify spending time teaching it.
In my company the default shell in the UNIX accounts is csh, and tcsh is recommended as a "nicer" csh. They do have bash if you want to use it, but they only "support" csh and tcsh. As a result, many important scripts by engineers are written in csh/tcsh. People who've never used bash. Very annoying, as for those who choose to use bash are often told they have to go into tcsh to get a given program to work, etc.
I think it's worth focusing on Bash, but at least contrasting it with csh and pointing out the lineage and other options. Perhaps spending some time writing some scripts in sh since there is a large install base of outdated or missing Bash.
I have no idea what schools think about this. I generally prefer deep knowledge in a single language, but there is value in learning a bunch of languages so picking up yet another new language is trivial. When I've spent too much time in one specific language I've found it harder to switch around.
My company still does intro lessons with ksh because it's set as the default shell on all of our servers.
The only time I found it to be a liability was when I was pair programming. My pair couldn't read a shell script to save their life & had very little interest in learning. When I tried explaining it line by line, they stopped wanting to pair because I was apparently making them feel stupid. They actually reported me to management for being an arrogant mansplainer. I'm pretty sure that was the beginning of the company deciding I was not a culture fit :P I had to learn how to, and how not to, work with someone less experienced in a certain topic after that.
Yes, cultural fit is real, and it isn't always about white men drinking craft beer.
One of the downsides of pair programming is that it's great when you both have complimentary skillsets. It's less productive when no one knows what the heck is going on. In this case, the task was to benchmark how many writes one could make to Kafka using our monolith. They wanted to see at least 10K/writes per second. The only problem was no one knew how to use Kafka (well), including the person who was asking for it.
So I wrote some gnarly looking Bash code to fire up Kafka, Zookeeper, the app, etc. Some people wanted to use Docker, but I didn't see the value in using a slower VM w/ limited resources. I wanted to use as much CPU as possible. My pair didn't know Docker, Bash, or Kafka. I lost my pair somewhere around talking about having to clean up zombie processes.
It went downhill from there.
Even if (at first) students just do a single `git add --all && git commit -m "finished project"` it goes a long way to just exposing people to the concepts. Provided the infrastructure is in place (eg GitHub or gitlab instance), it really isn't much different than dealing with a zip file, but provides 10x the educational value.
Bonus points to the prof that builds assignments that involve git branching from an earlier assignment.
Builds work quite different in Java, for instance.
CS 193 was a very low effort class (1cr), where you could follow the command by command instructions and perform all the tasks necessary to pass.
Unfortunately tools like git, vim, and shells all possess philosophies and concepts that are very hard to grasp without context, and constant use.
We were on multiple occasions told the mantra, add-commit-push, which I will say is enough for basic git usage, but since pretty much none of the subsequent classes used git to any capacity, I would assume many students lost all familiarity within the next semester (Makefiles that automatically git added and pushed code were used for submitting code).
I also think most people were hindered by vim, lacking sufficient instruction but still being presented it as the primary option.
I think if you’re going to implement a similar class / program, the tools really have to have uptake beyond a single course.
Sidenote, the different shell types weren’t covered in my semester, we just used bash / dash.
I think the trade-off on timing here is with internships during the summer after freshman year. I think you’ll have a much better chance of success if you’re at least roughly familiar with these workflows vs. interns who are totally unfamiliar with version control systems, for example. And perhaps that’s all the course is meant to accomplish at 1cr.
IMO it’s better to focus on fundamentals like math/algorithms that can be applied in multiple areas rather than specific tools.
Everything in a CS curriculum is easily Google-able.
Being functionally illiterate at the command line is harmful for productivity, so I think it's deserving of some in-class attention.
Imagine handing this to a person who's never heard of a shell, doesn't know how to `cd` or `ls`:
https://www.gnu.org/software/bash/manual/html_node/What-is-a...
> 1.2 What is a shell?
> At its base, a shell is simply a macro processor that executes commands. The term macro processor means functionality where text and symbols are expanded to create larger expressions.
> A Unix shell is both a command interpreter and a programming language. As a command interpreter, the shell provides the user interface to the rich set of GNU utilities. The programming language features allow these utilities to be combined. Files containing commands can be created, and become commands themselves. These new commands have the same status as system commands in directories such as /bin, allowing users or groups to establish custom environments to automate their common tasks.
"Macro processor?" "Expressions?" "Unix?" "Command interpreter?" "GNU utilities?" "Directories?" (you mean folders?) "/bin?" "Environments?"
My undergraduate advisor said since the second-semester lab was the basic lab, the first-semester lab had to be the basement lab.
Not in my experience, it isn't. Maybe for the first two years of undergrad but after that I've found that Google rapidly becomes useless.
The class almost went off the rails the first time before I realized half the students didn't know what a text editor or shell was. I ended up writing a document at a slightly lower level than this "missing semester" course (though taking some inspiration from it).
If I teach the course again, I plan to do one week shell bootcamp with "get to know your system" exercises spread throughout.
There are four quadrants of knowledge:
1) What you know you know
2) What you know you don't know
3) What you don't know you know
4) What you don't know you don't know
College is in large part about covering (4) and turning it into (2) or (1). You're describing turning (2) into (1) - you need to know what to Google in the first place.
The good ones are really CS + one extra year worth of projects and practical coursework, like learning what Agile is, Source Control, Build Systems and so on.
I didn't study Computer Science to learn how to write bash scripts.
Learning Outcomes:
1. Understand Unix/Linux commands for navigating directories and files and manipulating files and folders.
2. Understand terminal commands for searching and input/output redirection.
3. Understand shells such as sh, csh, ksh, tcsh, bash, zsh.
4. Understand debugging via print statements and general debugger concepts.
5. Understand version control via Git and Github, source control, workflow, commit, collaboration, pull, push, create and pushing a new repository, cloning, branches, merging, and conflicts.
6. Understand vim including mouseless navigation, normal/insert mode, copy/paste, search/replace, and saving/quitting.
https://selfservice.mypurdue.purdue.edu/prod/bwckctlg.p_disp...