back
89 comments
The course is quite opinionated, in a good way:

  It is essential to be able to efficiently use a text editor, and doing
  all your writing / coding / text processing in one of the common editors
  available on all Unix systems is good practice.  vi(1)/vim(1) and emacs(1)
  are popular choices.
My college instructor encouraged the use of emacs in particular. I eventually migrated to vim but appreciated the instructor’s core message that text editor + CLI feels less magical than a full fledged IDE.
After 10 years of writing software for a living I still don't get this. Why vim/emacs and not Intellij (for instance?). What do you mean magical - I want a powerful tool to help me edit code...
I'm assuming the rationale is that for someone who's doing complex system-level stuff on unix/linux they should be able to change things deep in the weeds instead of pulling the entire code out to IntelliJ or an IDE.
> I want a powerful tool to help me edit code...

Then why would you use Intellij and not vim/emacs?

Yeah, I'm torn on this. I wrote C in emacs for 20 years, and still do. But when I write anything else, particularly javascript, java and rust, give me intellij ide's...
Perhaps "magical" = increased complexity, like you can't just build a standalone source file. You have to setup a project first, configure the required build XML, add your code files to that project, etc etc then finally compile it.

with editors like vim/emacs, it's much simpler, like typing `vim test.c` and `gcc test.c -o test`. OK it's simpler, assuming you already have the toolchain installed properly. In general it's true, a few lines of apt-get/homebrew/etc get the job done.

BTW, I have nothing against IDE. As a Android developer, I won't ditch Android Studio for any editor. But for quickly navigating or building non Java codes, I'm happy with vim + Makefile/scons/etc. Or VSCode, if I'm not in the mood of running full featured IDE.

For coding in your normal day to day? Sure use intellij. For trying to debug some deep level production only issue where every second of downtime means big money lost? You'll want to know vim/emacs..

Edit: I'll also add that once you learn vim or emacs you'll be far more efficient manipulating text. Sure you could add the bindings to intellij, but I think that's admitting the point is valid. At a point it becomes like a real time meta language where you edit lines the way you would algorithmically.

Experienced emacs users will beg to differ. It is as capable and arguably, more easily extensible. I must admit, it is not for everyone. As your anecdotal 10 years experience, I have the opposite opinion but I think it is fair to say that both, Graphical IDEs and emacs/vim, have their merits. Having transitioned from Graphical IDEs -> vim + plugins -> emacs + evil + configs + org-mode. I will never go back to my old self, I've never been as productive and free.
One difference might be the pedagogical vs the productive perspective.

Perhaps the magic of a full fledged IDE is thought to obscure some of what is essential to the subject.

Quite simply, I may have to login into a server on a high pressure time sensitive environment, think downtime. I want to maintain my vim skills at a level that allow me to focus on the issue. It's also why I use bash and GNU coreutils on my MacBook Pro.
Sooner or later, in many lines of programming, you are going to find yourself remoted in to a server somewhere that only has the basic tools. That’s probably not the best time to try to learn an editor.
Because it teaches you that compile and run aren’t just buttons on a window, it’s taking one or more files (streams of text == data) and translating them into other files.
Who cares about java in this context?
Vim mode in intelij rocks
Same, the professor used Emacs in only programming class I took in college. Seeing what he could do with Emacs left as much of an impression on me as the rest of the material, and I've never considered another editor seriously since.
I'll just go ahead and shill acme: If you want to learn the Unix programming environment, vi and emacs are good in that they will work mostly as expected on any OS, but that's because they don't assume that you will use any user level applications. On acme, it's assumed you that have a shell, plumber and a whole load of commands and scripts ready to help out (as well as a mouse). In the process of learning Unix you learn acme for free and vice versa.
I don’t know man… Acme requires a GUI (and a mouse), has been imported from Plan 9 (Unix does not have a notion of a “plumber”), and its UI is pretty much a copy of Oberon’s. The way it look to me, this is as far removed from whatever Unix is all about as it gets…
To literally add my 2 cents: I use Geany for all code, whatever the language.
> learn to develop complex system-level software in the C programming language while gaining an intimate understanding of the Unix operating system

I would have loved to take a course like this in college, though I didn't have the chance. I do think [Rust In Action](https://www.manning.com/books/rust-in-action) is a good introduction to some of the same concepts, if anyone is, like me, yearning for grad school while having to hold down a job. While it doesn't use C, I think it teaches systems programming in a way that's easily applicable to any language.

If you haven't heard of Georgia Tech's OMSCS, give it a look. There are some excellent systems courses available.

https://omscs.gatech.edu/specialization-computing-systems

Can you take any of them through a MOOC platform such as Coursera, edx?
Neat, thank you so much!
> While it doesn't use C, I think it teaches systems programming in a way that's easily applicable to any language.

If it’s teaching systems programming in a way that’s applicable to any language, it’s probably not teaching systems programming.

I'm not sure what you mean. There are many systems languages out there these days: C/C++, Rust, Zig, and even Go and Nim for things like file systems and networking!
> Students are expected to have a good working knowledge of the C programming language, have written non-trivial programs before, and to be able to competently use a Unix system with a command-line shell interface. All coursework will be done exclusively on a Unix system from the command-line. This is not an introduction to using Unix!

My son just finished an undergrad CS degree at a major university and I don’t think he’d meet this pre req.

I’m not sure - I took an operating systems course in C that used command line only for submissions, and of course if you didn’t run a *nix locally you had to SSH in and work in a terminal environment for the entire course. This was three years ago. You could nitpick about what “non-trivial” means, but I’d say most CS degrees require some non-trivial work(to them).
> My son just finished an undergrad CS degree at a major university and I don’t think he’d meet this pre req.

Wow, that's somehow sad : - |

That's kind of the point of splitting CS degrees into general undergraduate basis and specialized graduate level. In undergraduate you have to learn the basics of everything and can start to specialize on projects or bachelor's thesis if your uni has one, then you finish your specialization during graduate studies. You can be a very good software developer without ever touching a command-line interface or having a working knowledge of C these days. On the other hand if you want to become a C/Unix developer, there are enough courses and projects available for you to learn.

Also I'm fairly sure you can start a course like this even without matching the prereqs, it's just gonna be a bit harder, but university is all about challenging yourself...

Many peers at my CS program (I graduated a few years ago) also wouldn't meet these prereqs.

1. Exclusive use of Windows. You couldn't submit binaries unless it was compiled with msvc.

2. Junior year was when we were first taught the shell. This was a major challenge for many as they didn't understand commands like `cd` or `dir`.

3. C was never taught, even in our OS course, it was all C++.

4. When working on my senior project with my team, one of my teammates asked if his code needed to compile (the IDE had riddled his code with red underlines for the many, many syntax errors)

5. Bonus: Git was never taught. When I suggested to a teammate that we collaborate on GitHub he instead emailed me his code.

So? This is a specific course with specific requirements. Many unis today don't teach C nor require students to be familiar with Unix, but if you think about writing server-side software it's an excellent introductory course.
There's some debate about the role of practical instruction at engineering colleges. One one hand, you have people who say "no. we shouldn't be teaching basic skills like C programming." Their point is a university level education is supposed to teach people how to think about the concept of computability and algorithm analysis. They will frequently say things like "we are not a trade school!" The other side of this debate are people who are like "Meh. It's embarrassing our grads can't write a C program." So they teach them Python.

Either way, the only way you're going to graduate knowing C programming is to realize it's something you want to do and spend a bit of your own time learning it.

And then they completely fail to teach concepts usable as a gigging coder.

I think if you ask the academy "what are you teaching young software engineering students?" the response would be something along the line of "We're teaching them knowledge and skills that will be useful for being a grad student."

It would be cool if there was an organized course teaching kids the basics of version control, what continuous integration and continuous deployment are, what agile methodologies are supposed to do (as opposed to "agile is whatever is in the JIRA manual"), the basics of logic programming -- you'll never use prolog but you'll be rewriting it in C++ or C# a couple of times, the basics of functional programming -- you'll never use lisp, but you'll be pretending function pointers are the same thing when you're writing that big C++ program, software project estimation, how to invert a binary tree -- you'll need to know this for a google interview and how to actually design data structures.

UNIX sucks. Of course, enough time has passed that people expect a mathematics degree to come with diarrhea from the 1970s for stupid reasons.
> Letter grades will be given as follows: > > * 90% - 100% of total available points => A > * 80% - 90% of total available points => B > * 70% - 80% of total available points => C > * 0 - 70% of total available points => F > > Within each letter grade, there are +/- grades given at the discretion of the instructor. (Exception: there is no A+)

...what? O.o

They don't offer a grade 'D' anymore?

Common in grad level courses that 70% is required to pass
Previous discussion:

https://news.ycombinator.com/item?id=25775168 (188 points | Jan 14, 2021 | 41 comments)

I believe this course (or something close to it) was taught in the University of Kent when I was there between 2009 and 2013. Really got my Linux game up to the point where I could switch to it fulltime.
I took this class during undergrad! It was really enlightening as a web developer to actually...write the server
I took this class while I was in grad school! Ended up dropping due to reasons but the instructor was great. I'm pretty sure the course materials are up on YT as well.
The moment I read APUE, the website apuebook.com flashed into my mind. I've been following Stevens and Rago book since their first edition which was late 1990s.
The course home page almost looks like it could've been for a Unix programming course 30 years ago.
Because a modern programming course page must have 30 MB link to 3 analitycs pages and have Facebook and Tiktok tracking and buttons. Nevermind that the main info is 1kB. /s
excellent, wouldn't expect anything less.
I think it's good - loads quickly, straight to the point, materials are available easily (links to yt)
looks cool but this sentence "and all OS that belong to this family, such as Linux, the BSDs, and even Mac OS X" triggers me a bit because MacOS is the only one of those OS' listed that are certified UNIX.

Technically Unix is trademark, you have to pay to be Unix.

Which also implies meeting certain certification tests criteria, it isn't only just money.
You're talking about Unix the intellectual property.

They're talking about Unix the philosophy.

I recommend to use UNIX® in the course name as the text book consistently uses.