grenzland.club is a Fediverse instance that uses the ActivityPub protocol. In other words, users at this host can communicate with people that use software like Mastodon, Pleroma, Friendica, etc. all around the world.
This server runs the snac software and there is no automatic sign-up process.
spent my evening installing KiwiIRC for our little #IRC network. It's a web chat portal, giving access to our little #ttrpg #unix network (the GrenzlandNet? Did we agree on that name?)
Anyway, spent most of the time trying to validate the json file used for configuration, and then a bit more time trying to make it play nice with caddy. Still not sure if it actually does. But if it does it should be reachable under https://chat.wilderland.ovh/
I really didn't get the appeal of tiling window managers at first, but then I discovered ion(defunct, now replaced with notion), which adds in stackable panes. Each window pane can contain more than one child window. A simple mouse click or Mod4+Tab shifts between them.
Beyond that, its just some basic controls. Mod4+F1 opens a web browser, F2 is a terminal, F3 is a run dialogue, F4 is an SSH session, stuff like that.
The thing I really like about notion is that opening a new program does not cause your existing layout to change. You draw the layout first, and have a series of empty panes that you can populate with applications. You can even drag windows between panes. I really dislike how most tiling window managers are always dynamic, all the time. You open a new thing, and BAM, all of sudden everything else has moved and shifted in size. I'm a very position oriented person. I like to put things in a particular spot, and leave them there, so I can find them later.
I really dislike modern desktop environments. They are slow, obtrusive, and waste entirely too much screen real estate on useless things like toolbars. I want the user interface to be as simple as possible, and to stay the hell out of my way.
So, this is my #UNIX (#FreeBSD specifically) workstation. Four monitors. I generally keep the web browsers and other large GUI applications to the full screen panes on the left, and use the right for my terminal windows and smaller applications. But I _always_ have an xterm open in every single pane. I can never find a terminal fast enough when I am angry|stressed|tired|etc. 😜
So, this is how and why I do things the way I do on a computer. I'm hoping so of y'all will post screenshots of your own, and talk about what works for you. Because we are all different, we all have different ways of thinking, needs, and desires. And to quote Chris Boden, "That's pretty cool!"
Oh, if someone submits a better #alttext, I will totally use it.
#introduction version... dunno... 12?
German, he/him, 40s, living in Poland (#lodz). I work in IT and do some geeky computer stuff on the side (#usenet, #irc, #unix, #linux)
My main hobby are #ttrpgs (#osr #dnd, #traveller, #shadowrun) and similar (#minipainting, #boardgames) but I also do writing and reading (#fantasy, #sf) and #cooking.
I will be complaining about #kids, #cats, lack of #coffee, and the general state of the world
I do get weirdly obsessed with topics. But don't we all?
Misspiggy’s decwriter is accepting logins to the decsystem-570 running #unix version 7. You can connect yourself at https://connect.sdf.org #vintagecomputer #retrocomputer
ok, working on #OpenIndiana I am not quite sure if I even have the right repositories. According to what I read online the hipster-encumbered repository should have all kinds of different things, not just 63 packages.
I feel like I am missing something here.
Sean Haas' talk about the Unix Wars mentions Bill Plauger and Idris history!
#lispyGopherClimate #live on #peertube again ! https://toobnix.org/w/gXLXQqxf5MYg1NDF2Ua6oA anonradio one is replay
On the hour!
Hopefully joined by @kentpitman and @ramin_hal9001
Viz the #climateCrisis I am hoping to talk about the #debian #llm thing viz @cwebber https://gamerplus.org/@cwebber@social.coop/117508713815802595
the wonderful @nosrednayduj clued me into #symbolics #lisp discussions and the paper on failure https://www.chai.uni-hamburg.de/~moeller/symbolics-info/Symbolics.pdf
ALSO our @dougmerritt and #unix and #gamedev and #softwareArchaeology
Chat in #lambdaMOO #VR as always!
It’s vintage computer repair meeting time at the Nürnberg FabLab again! Amazingly, the Sun 3/50 board works out of the box, while my trusty old 3/60 throws a memory path data test error, bits 26 and 21 at address 0x400 are stuck at 1…
Advanced Programming in the #UNIX Environment
In this class, we use #NetBSD as our reference platform. In addition to our shared shell server, here are some ways you can install NetBSD:
- put it on e.g., your laptop: https://netbsd.org/docs/guide/en/chap-exinst.html
- use VirtualBox: https://stevens.netmeister.org/631/virtualbox/
- use UTM: https://stevens.netmeister.org/631/utm/ (Video instructions: https://youtu.be/hCqfmuG5Acc )
- use or create an AWS image: https://stevens.netmeister.org/615/netbsd-amis.html
- create your own NetBSD #Linode: https://www.netmeister.org/blog/netbsd-on-linode.html
Advanced Programming the #UNIX Environment
Week 1: UNIX History
We cover the early days at Bell Labs, USL vs BSDi, the birth of the BSDs and #Linux, and how we got from Ken Thompson playing "Space Travel" on a PDP-7 to Unix running on your phone, fridge, and TV.
Scroll along through it all here: https://levenez.com/unix/unix.pdf
Advanced Programming in the #UNIX Environment
Week 1, Unix Basics
We write our first trivial program, which promptly segfaults and gives us a chance to explain function forward declarations and maneuvering man pages and set our default compiler flags ("-Wall -Werror -Wextra"), then proceed to write the most trivial versions of cat(1), ls(1), and even a rudimentary shell including a signal handler.
Advanced Programming in the #UNIX Environment
Week 2: File Descriptors
To introduce the concept of file descriptors, let's start with a simple question: how many file descriptors can a unix process open? Finding the answer helps us introduce a few different limits that may apply across the system, for a given user, or just a process.
As a fun exercise, try setting "ulimit -n 0" in your shell and see what happens. Can you explain why?
Advanced Programming in the #UNIX Environment
Week 2: open(2) and close(2)
Having introduced the concept of file descriptors, let's look at what happens when we try to create a file, "create" an existing file, open an existing file, truncate a file, and look at the various other flags we can pass to open(2). We also note the perhaps surprising number of ways in which open(2) can fail and take a look at openat(2) and TOCTOU defenses.
Advanced Programming in the #UNIX Environment
Week 2: read(2)/write(2)/lseek(2)
In this video lecture, we will go into the details of the read(2), write(2), and lseek(2). We'll also do a few weird things with file descriptors, and take a look at how we can ensure I/O efficiency when making these system calls.
Advanced Programming in the #UNIX Environment
Week 2: File Sharing
In this final video lecture segment for our week 2 materials, we take a look at what it means when multiple processes access the same files and what the implications of that are on the syscalls we know. We conclude with a look at /dev/fd on different operating systems, including #NetBSD, #macOS, and #Linux.
Advanced Programming in the #UNIX Environment
Week 3: stat(2) intro
In this video lecture, we meet our new best friend, the 'struct stat'. We'll cover the stat(2) system calls and begin discussing each of the fields in the struct, often by example of the ls(1) and stat(1) commands. In this way, we begin learning more about how the Unix File System is implemented.
(Note that the output of stat(1) on #NetBSD is different from that on #Linux.)
Advanced Programming in the #UNIX Environment
Week 3: UIDs and GIDs
In this video lecture, we'll learn a little bit more about file ownership and the user IDs of a process (real, effective, saved) by looking at the seteuid(2) and setuid(2) system calls and experimenting with setting the setuid bits and observe the file access we gain.
Advanced Programming in the #UNIX Environment
Week 3: struct stat st_mode
In this video segment, we're looking at how the traditional permissions defined in the `struct stat st_mode` are applied. You want to pay particular attention to the permissions on directories and the order in which they are checked. One thing that often surprises newcomers is that to delete a file, Unix does not care about the permissions on the _file_, only on the directory it's in.
Advanced Programming in the #UNIX Environment
Week 3: chmod(2) and chown(2)
Having seen a lot of examples in our previous videos of creating files, changing their ownership, changing their permissions, we now focus on the system calls that are used to implement the chmod(1) and chown(8) commands.
Advanced Programming in the #UNIX Environment
Week 3: umask(2)
In this video lecture, we'll take a look at what file ownership and permissions are applied when we create a new file. In the process, we'll learn about the concept of a process's "umask", and look at how the 'umask' shell built-in is implemented.
Advanced Programming in the #UNIX Environment
Week 3 (and 4, kind of): Union Mounts and Whiteout Files
One of the file types we've encountered are those of type S_IFWHT, so called "whiteout" files. But what the hell is that?? Let's illustrate! We describe the concept of union mounts and see what happens when a file in the upper layer is removed while the same file still exists in the lower layer: a whiteout file is created to cover up the lower file.
Advanced Programming in the #UNIX Environment
Week 3: recap
Slides from tonight's class, summarizing the last few videos and adding a few more bits (haha, get it?) about how the umask works.
Advanced Programming in the #UNIX Environment
Week 4: The Unix Filesystem
This week, we'll take a closer look at the Unix Filesystem (UFS). In our first video segment, we visualize how the filesystem structures the disk and organizes files and directories. We illustrate how directory entries are created and moved around.
Advanced Programming in the #UNIX Environment
Week 4: Links
In this video lecture, we'll take a look at the system calls used to create, remove, and rename both hard- and symbolic links. We'll compare expected output against trivial implementations of the ln(1) and mv(1) commands.
Advanced Programming in the #UNIX Environment
Week 4: Directories
In this video, we take a look at how directories are created and removed, as well as how to move around the filesystem hierarchy. We also learn how directory permissions are applied, why the 'cd' command must be a shell builtin in order to work, what happens when you remove a directory you're currently in, and we revisit our simple ls(1) clone from week 1, using opendir(2) and readdir(2) to list files.
Advanced Programming in the #UNIX Environment
Week 4: Directory Size
Let's dive deep into the structure of the directory on a traditional Unix File System and see how its size is independent of the file sizes of its entries, but dependent on the filename lengths. We'll also use hexdump(1) to cheat a bit and look at the actual directory structure on disk.
Advanced Programming in the #UNIX Environment
Week 4: /etc/passwd
In this short video, we try to answer the awkward question "Mommy, where do UIDs come from?". We look at the /etc/passwd user database and identify the various fields before we look at how things can get weird.
Advanced Programming in the #UNIX Environment
Week 4: getpwuid(2) and /etc/groups
After having discussed all the account fields in /etc/passwd, we now look at the library functions used to look up that information. We learn about how primary and supplementary groups are handled as well as how the hashed passwords are stored outside of the world readable /etc/passwd file.
Advanced Programming in the #UNIX Environment
Week 4: atime, mtime, ctime
In this video lecture, we start looking a little bit closer into what our systems think of "time", something that experts most accurately describe as a big ball of wibbly, wobbly, timey, wimey... stuff. In short, analyze how the atime, mtime, and ctimes of a file connect.
Advanced Programming in the #UNIX Environment
Week 4: time(3) is an illusion
Having revisited the atime, mtime, and time in our last video segment, we now have to come to terms with time(3) itself. We'll discuss managing the data structures and handling arbitrary concepts such as leap seconds, timezones, and (ugh) Daylight Savings Time. It gets silly real quick.
For a lot more time based shenanigans, see also:
Advanced Programming in the #UNIX Environment
Week 5: The Unix Development Environment
This week, we're looking at the Unix system as an effective Integrated Development Environment. This introduction outlines the different tools we will cover in subsequent videos. (You may notice it is a bit dated already in it's references to AI from back in 2020. Good thing we don't allow the use AI in this class, so you've got nothing to worry about.)
Advanced Programming in the #UNIX Environment
Week 5: The Editor
In this video lecture, we look at the required feature for a full-fledged programmer's editor and illustrate some of the core functionality by example of #vim. This includes basic motion commands, setting and moving to markers, using folds, and the integration with build tools, such as the compiler, debugger, and 'make', all of which we will cover in the next videos.
Advanced Programming in the #UNIX Environment
Week 5: ed(1) is the standard text editor
What? You thought we could skip ed(1)? No way! It's the standard text editor. ed man! !man ed
But understanding ed(1) also helps us understand other tools like vi(1), sed(1), and ultimately even things like diff(1) and patch(1) better.