CS631 – Advanced Programming in the Unix Environment
stevens.netmeister.org
stevens.netmeister.org
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.
Perhaps the magic of a full fledged IDE is thought to obscure some of what is essential to the subject.
Then why would you use Intellij and not vim/emacs?
There was a research implementation to write Solaris drivers in Java.
https://dl.acm.org/doi/10.1145/1215995.1215998
The Sun network computing thin clients had plenty of Java into them.
The classical UNIX does one thing well myth was hardly followed by all major UNIX vendors.
One thing I never understood was why I couldn’t just write some Java, compile it [0], and hand the result to someone else on a Solaris system, and have them run it.
Sure, they may know how to run “java -jar myapp.jar”, but why was that necessary? Why couldn’t it be a standalone executable, that didn’t require the end user to know in advance that it was written in Java and to invoke it accordingly?
Every single bit of Java software I ever used on Solaris always had some sort of shell script wrapping it. I never understood why the operating system couldn’t just natively execute Java code… they literally wrote the entire operating system, language, compiler, toolchain, etc, and the end result wasn’t usable without arcane wrapper scripts and JAVA_HOME conventions and so forth. Windows managed to make it work with .NET (they were just .exe’s like everything else), I always thought like Sun could have done so much better with the end-user experience with running Java software.
[0] for any loose, reasonable definition of “compile”. I’m not saying it can’t be byte code, that’s fine… I just don’t want to have to care. I should be able to copy it to /usr/bin and just run it without having to invoke “java -jar”, or use some weird self-extracting shell script trick. And I shouldn’t have to care about whether the person I’m distributing it to has Java installed, because it should have always been the case that a given SunOS machine should have a working Java install… the same company made the OS and the language for chrissakes, every SunOS installation should have had it as a mandatory component.
(To be fair, these could be defended, very slightly, on the grounds that Java is a cross-platform language, even though other cross-platform languages have better answers. But then I'd raise the point about Java corrupting RLIMIT_FILES for processes it starts....)
I love vim, I really do, but IntelliJ is a Java-specific IDE and there is absolutely no way that vim or emacs or vscode can compete on features. You can refactor code in a split second in ways that are just not possible in vim/emacs. IntelliJ has an understand of the structure of your Java code that vim simply doesn't have and will never catch up to having as its a general purpose tool and IntelliJ is a specific tool. Its vim mode is also pretty good. The only downside of Jetbrains IDEs is that they can be slow when indexing large projects and they can be slow in general. But I would still 10 times out of 10 choose to make a commit in IntelliJ over vim for a Java project that is non-trivial.
If you write Java I would (as strongly as possible) recommend giving IntelliJ another go and looking into its refactoring and other features.
Java is neither common nor especially well suited for the topic of this course.
So while I share your opinion on IntelliJ as a Java IDE, I would not recommend it for UNIX systems programming. And even the IntelliJ-derived Clion, which is (IMO) decent for that, leaves something to be desired when it comes to learning the topic.
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.
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.
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 it’s teaching systems programming in a way that’s applicable to any language, it’s probably not teaching systems programming.
My son just finished an undergrad CS degree at a major university and I don’t think he’d meet this pre req.
I’d love to hear what the author considers nontrivial but I’m going to guess it has something to do with pointers, and familiarity more generally with the memory model of C.
I took a few undergrad CS courses during some downtime recently and found them blindingly, disappointingly easy to the point where I found myself fading the (prestigious) school that created the material. They felt completely trivial, as did the assignments.
On the other hand, I'd be willing to entertain the argument that I've not yet written a non-trivial program in my ~10 years working.
Wow, that's somehow sad : - |
I used to work out of a space provided to my employer by a university, as part of their startup accelerator program
It was on-campus and there were students also in that space, so during lunch and breaks I got to know many of them
In my experience, students about to graduate from the CS program had near-zero tangible skills and lacked the ability to build basic applications, in any language.
This was in the USA, FWIW. I think our CS programs are pretty trash at most universities.
One of my current coworkers applied after graduating and failed the interview and was only able to pass after paying thousands to attend a coding bootcamp.
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.
But they didn't teach C programming. I actually taught the Intro to C Programming class in the Continuing Education department.
It might be the equivalent of a chemistry department saying "We'll teach you how not to blow yourself up in the Organic Chem Lab, but we won't teach you how to use a calculator."
But yeah. Seems every school is slightly different about where they want to draw that line. And most every school I've seen has more practical work than they did 40 years ago.
And to bang on my usual academic CS bugbear on HN: algorithms is one class. It might be the most important class, or the only class in the intersection of all CS experiences, but each person's experience includes like 15 other courses. Some, perhaps even most of those should be systems. And systems classes should include substantial C programming.
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...
No disrespect but that isn’t true. Touching the command line is required for sure.
I didn't go to a university to learn anything about computers, fortunately.
The best env to complete SICP it's, paradoxically, a Unix like system written in C with an Scheme DSL to set up the system declarativelly.
Actually that’s exactly what Nicklaus Wirt did with Oberon.
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.
...what? O.o
They don't offer a grade 'D' anymore?
https://news.ycombinator.com/item?id=25775168 (188 points | Jan 14, 2021 | 41 comments)
Technically Unix is trademark, you have to pay to be Unix.
They're talking about Unix the philosophy.
"Unix the philosophy." seems to be a thing only on FOSS UNIX clones, and even then, "man anything" shows how far the reality is from the myth.