yeah ncurses is what you use if you want to draw ascii on the screen and keep it in position, and control where the cursor sits at all times
for linux terminal, make a loop that directly listens to input and respond to the input by making system calls - that's the most direct and simple (if you haven't done that yet)
if you haven't tried making a simple text based adventure game, it fits into this category of reading structured text input and responding
or for a more complex possibility, going the socket server route and emulating terminal input is a lot more advanced
if you're playing with systems level unix stuff, a good overall book with lots of examples to try is:
https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739
working thru the examples in:
https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739
might be a good start on systems level programming in C in general. most of it isn't explicitly kernel development, but if you haven't done any systems level stuff, it might be good to learn that level of things first. i have done only minimal actually-within-the-kernel work, so i can't speak too much to below this layer, though.
Dbus is Linux specific, right, whereas most other Inter process communications - pipes, sockets, shared mem (everything I vaguely remember from the Advanced Prog Unix Bible) is posix and implemented on BSDs, Solaris, even Windows?
Backend is more about solving problems about data, streams, and other forms of communication. It is necessary to learn a framework, but it's not like front end where React === career.
If you want a full-stack career at a small-medium sized company then you only need to learn the basics of API design, and different patterns that suite web services. However, if you want to be a true backend dev that can handle anything and everything, then you should read these:
> Another way to say it is that a snapshots “USED” size only accounts for unique blocks contained in that snapshot. That’s why when you delete a snapshot the only blocks freed are the ones that were uniquely held by that snapshot.
Aah that makes sense. I'm currently reading through the Snapshots chapter in this book: FreeBSD Mastery: ZFS. The examples of snapshot space consumption only had examples 2 or 3 snapshots deep, so not too many cases where (like in my case) the blocks are probably shared between several dozen snapshots.
Thanks!
c or c++ is the right place to be for really low level stuff on unix
pick up the "unix bible" (https://smile.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739) and try examples in all the different systems routines
for example make a socket server and something multithreaded with mutexes and conditionals and use unix messaging and global shared memory, play with signals, etc etc
try writing a kernel plugin of some sort
It supports different cpu architectures, e.g. ARM and X86. However, it does not support different scheduling. In fact, the different approach towards CPU locking is one of the main reasons that leading to Dragonfly BSD.
The source code is orthodox, comparing to the Linux kernel source code. It is because there are always people trying and researching different things within the Linux kernel space.
It is relatively easier to read the FreeBSD source code along with this book if you want to learn OS architecture.
This might be a good place to start.
yea, Windows is pretty much useless unless you are at a school that is going to push you through multiple (4+) C#/WPF development classes.
Otherwise, Linux has MASSIVE advantages over Windows, so everything you create will be a *nix based OS. There might be something new that pops up in the next couple of years but RedHat is super duper strong. You should start learning about shared object files, ELF (Executable and Linkable Format), and just the general ecosystem. It is a rabbit hole so try to balance life and studying; however, if there is any time to explore Linux it's when you are an EE student in college. Also, never switch your major.
Read this before you graduate: https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739
If you want to be a hardcore coder, then take as many CS/CE classes that you can. If security interests you then double major in math, you will thank me later.
There is already described how CPU works. OTOH there is some other aspect to describe.
First, there are kernel virtual space and user process virtual base. In a most typical setup (like for x86), they share a common space but kernel one is at top half of the whole space. (In x86-32 in a special mode before mass migration to 64 bit, it could be top 1/4 or even 1/8 of the whole space.) This space maps kernel code and data in a rather free way, it can allocate and free any space portion. But, it has to keep some data structures that track use of the whole physical address space (free/occupied, who occupies).
OTOH, specific platform issues add some more restrictions. For example, it is highly suggested that when DAT is turned on or off on x86, this is done from an equal-mapped page (virtual address is equal to physical one). With typical Wintel platform, this means it is most handy to put the code for this switching and some page catalogs to first 1MB (and make it unavailable for userland - that's why often start address of Linux process is 4MB).
Also, each userland process has its own virtual space structure (its part, complementary to kernel one) which are described in OS-specific structures. At Linux, /proc/$pid/maps describes them. A book like this describe them in details.
I've referenced this behemoth a bit and it could be helpful if you really want to get into the thick of things.
generally recommended for unix systems programming, tho i'd go with the more specific links the others have dropped first
https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739/
if you're going to be working on low level things in a unix environment, then consider poking around with come C tutorials and working through the examples in
https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739/
In the language of the design and implementation of the 4.4 BSD , the bottom half of the kernel is Mach micro kernel, whereas the top half is monolithic drivers etc. Can I think it this way?
As others have mentioned, man pages, the Handbook and also the FreeBSD FAQ are good starting points. I'd also recommend Absolute FreeBSD: https://www.amazon.com/Absolute-FreeBSD-3rd-Complete-Guide/dp/1593278926
As an experienced Linux user many things will seem familiar, so I guess you could read that book only topically
FreeBSD is a fantastic OS.
I recommend getting the books The Design and Implementation of the FreeBSD Operating System & Absolute FreeBSD
The FreeBSD No Starch book just came out a year and a half ago and the Handbook is constantly updated so I don't know why you think they're outdated.
In addition, if you really want to get into the bowels of the FreeBSD operating system
What I am doing right now is reading this book alongside with the source code of 11.4.
On and off I build the kernel and try to understand it’s output and the overall make infrastructure.
LOL it seems interesting to me. I'm reading https://www.amazon.ca/Design-Implementation-FreeBSD-Operating-System/dp/0321968972/ref=dp_ob_title_bk right now.
​
Maybe its good in theory, and not in practice.
Advanced Programming in the Unix Environment by Stevens Also the best book for everything else.
Geany might be a friendly alternative to VS. Otherwise GCC-G++ and make files are your friend. A decent book to read on how to utilize the power of Linux with c/c++ is Advanced Programming in the UNIX Environment :
https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739
It will teach you about headers you won't find on Windows and how to program the whole operating system using c. But this can always be extended to c++ since c++ is a superset of c.��
Ext4 has sort of just been around for forever (since it's revisions of Ext3 and Ext2) and I always just accepted it as "there". Sort of like NTFS for Windows, it's the thing you use with Linux.
For ZFS, I did come across this ZFS on Linux admin guide a few months back and it's been really useful in getting to the nitty-gritty. And of course, there's always Michael Lucas and Allan Jude's book on ZFS for FreeBSD.
It will teach you the semantics of the posix interface and introduce you to some canonical utilities. That information is relevant today (we still use sed, make, etc..). Given the choice, I'd probably opt for a book specific to linux, freebsd, etc.. kernels alongside something like unix power tools.
The ZFS technology is that require ECC. You can use non-ECC hardware at your own-risk, but you can still use it with a relative safety. OpenMediaVault do not have ZFS technology. So you can use standard hardware.
ZFS have several advantages. You want to dig into more information read this book: http://www.amazon.com/FreeBSD-Mastery-ZFS-IT-Book-ebook/dp/B00Y32OHNM
OpenMediaVault is a good option too.
Assuming you're using Linux/Unix/BSD, this book will be invaluable: http://www.amazon.com/Advanced-Programming-UNIX-Environment-Edition/dp/0321637739
To start with, read up on select(), as that will be your friend. Doing something like this will be really tricky to get right.
I've seen this monkey in my dads house on the book shelf. Can't say I noticed the title though. He works with Oracle, so you might not be too far off. Can we figure out what it is?
Found it: http://www.amazon.com/Unix-Nutshell-Fourth-Arnold-Robbins/dp/0596100299/ref=ntt_at_ep_dpt_3