Best linux programming books according to redditors
We found 119 Reddit comments discussing the best linux programming books. We ranked the 30 resulting products by number of redditors who mentioned them. Here are the top 20.
We found 119 Reddit comments discussing the best linux programming books. We ranked the 30 resulting products by number of redditors who mentioned them. Here are the top 20.
Here's my list of the classics:
General Computing
Computer Science
Software Development
Case Studies
Employment
Language-Specific
C
Python
C#
C++
Java
Linux Shell Scripts
Web Development
Ruby and Rails
Assembly
In short, the answer is virtual memory and the protected mode flat model that the past generations of CPU architecture and operating systems have been using.
As you may know, programs are never given full, direct access to the RAM banks; the operating system abstracts this layer away from them in the form of virtual memory. Virtual memory is basically a system whereby you can map physical memory addresses to non-physical ones the OS controls and can readily re-arrange. Thanks to virtual memory the OS can trick an application into thinking it has way more RAM than it actually has and this also enables swapping processes out to disk when the system is running out of memory because there are too many processes being run at the same time. As I pointed out before, since virtual memory is fully managed by the kernel, it can move out chunks of a program's address space to disk, a process known as "paging".
Now, back in the DOS era, virtual memory followed the real mode segmented model, which, in very simple terms meant that, even though processes could be shuffled back and forth between RAM and disk, there were no safeguards in place to prevent a process from messing up another process' memory space via a dodgy pointer pointing to a memory address beyond the scope of the faulty process.
One of the major goals of the successor to this virtual memory model, "protected mode flat model" was to allow the kernel to create a completely isolated address space for the processes it spawns and stopping a rogue program from altering other processes like before. Whenever such an attempt is made, a "segmentation fault" (SIGSEV) or "general protection fault" is raised by the kernel, which in the case of Linux, will prompt the kernel to swiftly kill the offending process.
In practical terms, this means your application won't be able to reach beyond the virtual memory address space it has been allocated (unless it's a kernel-space process, like a kernel subsystem or device driver) and can in no way communicate with other processes by reading or writing memory that belongs to them. In order to accomplish that, you'll need to make use of inter-process communication (IPC) techniques like Unix sockets, pipes, RPC, etc.
This is by no means an in-depth or 100% accurate explanation though. If you've got any follow-up questions I'm more than happy to answer them.
As for the literature, pretty much any textbook about operating system architecture will cover virtual memory to a great extent. I can recommend Operating Systems: Internals and Design Principles and Modern Operating Systems.
Here are a few more books that touch upon the topic of virtual memory:
Assembly Language Step-by-Step: Programming with Linux covers the topic of virtual memory and the different models that have evolved over time over its first few chapters.
The Linux Programming Interface: A Linux and UNIX System Programming Handbook covers this subject (and many, many more) from a Linux systems programmer perspective.
What Makes It Page?: The Windows 7 (x64) Virtual Memory Manager, in case you're interested in learning how Windows does it.
EDIT: added IPC info
I have the UNIX and LINUX System Administration Handbook It's awesome and has a pirate boat on the front, so you know it's good. It's great for best practices type stuff, and there's a little bit of sysadmin humor mixed in.
I also have the Linux Command Line and Shell Scripting Bible which is good for CLI reference.
Other than that, you can find a ton of stuff on the web. Is there anything in particular you are looking for?
>I do have a textbook called "C: A modern approach" by King, but like I said before, I think it focuses more on the coding aspect.
Most books that focus on C are going to be about learning the language. If you want to learn low level stuff, you need to find books that focus on them (and they'll usually incidentally use C). The language itself is quite small and minimalistic in what it can do. Most heavy handed things like networking and GUIs require interaction with the OS.
Eg, if you wanted to do networking, you could use the Windows API or the POSIX socket API (POSIX being the standards that *nix systems follow -- and certain versions of Windows). Or you could use a higher level library like curl for cross platform support (and a wealth of nicer features).
>Can somebody please guide me on where to start?
Firstly, as much of a linux fanboy I am, I do want to make sure you know that you don't need to use Linux for any of the other things you wanted to learn (low-level programming, command lines, networking, etc). In fact, my OS class mostly used Linux, but we started out with a project using Windows threads (I guess the prof wanted us to see the difference from POSIX threading).
All that said, I do think Linux is something you'd want to learn and that a lot of low level things just seem more natural in Linux. But I'm biased. Linux fanboy, remember?
I'd start with downloading a Linux OS. Doesn't really matter which. I'd recommend going with Ubuntu. It's the most popular, easiest to find help with, and seems to be what most web servers are running, to boot. You can play around with the GUI for a bit if you want. It won't feel that different. Modern OSes sort of converged into the same high level ideas.
My favourite book for getting into the command line ever so slightly touching the low level aspects of OSes is Mark Sobel's A Practical Guide to Linux Commands, Editors, and Shell Programming. It will include some basic knowledge of Linux, but mostly focuses on the command line. But this is very useful because not only is the command line very practical to learn, but you'll end up learning a lot about Linux in the process (eg, by learning how everything is a file, how pipes work, etc). And arguably the command line a super big part of Linux, anyway. It makes sense as the first step.
Now, for the next step, you need to know C very well. So finish with your class, first. Read ahead if you have to. Yes, you already know if statements and functions and all, but do you understand pointers well? How about function pointers and void pointers? Do you understand how C's arrays work and the usage of pointer arithmetic? How about how arguments are passed to functions and when you'd want to pass a pointer to a function instead? As a rough skill testing question, you should implement a linked list for arbitrary data types with functions such as prepending, appending, concatenating lists, searching, removing, and iterating through the list. Make sure that your list can be allocated and freed correctly (no memory leaks).
Anyway, the next step is to learn OSes. Now, I said OSes and not Linux, because the Linux OS is a bit constrained if you want to learn low level programming (which would include a knowledge of what OSes in general do, and alternatives to OSes like Linux). But never fear, pretty much any OS book will heavily use Linux as an example of how things work and consequently explain a great deal of Linux internals. I can't recommend a class because mine was a regular university class, but Tanenbaum's Modern Operating Systems is a good book on the subject.
In particular, you can expect an OS class to not merely be focused on building an OS yourself (my class worked on aspects of OS101 to implement portions of our own OS), but also on utilizing low level aspects of existing OSes. Eg, as mentioned, my class involved working with Linux threading, as well as processes. We later implemented the syscalls for
fork,join, etc ourselves, which was a fascinating exercise. Nothing gets you to understand how Linux creates processes like doing it yourself.Do note, however, that I had taken a class on computer architecture (I found Computer Organization and Design a good book there, although note that I never did any of the excerises in the book, which seem to be heavily criticized in the reviews). It certainly helps in understand OSes. It's basically as low as you can go with programming (and a bit lower, entering the domain of computer engineering). I cannot say for sure if it's absolutely necessary. I would recommend it first, but it's probably skippable if you're not interested (personally, I found it phenomenally interesting).
For learning networking, Beej's book is well written. You don't need to know OSes before this or anything.
I was there today and I bought two books:
http://www.amazon.com/Assembly-Language-Step-Step-Programming/dp/0470497025
and
http://www.amazon.com/Programming-Python-Mark-Lutz/dp/0596158106/ref=sr_1_5?s=books&ie=UTF8&qid=1299370602&sr=1-5
I get to the counter..."There are no refunds or exchanges, just a heads up man". Yeah, so what? No problem.
Then he proceeds to take out a black indelible marker and scribble on the back of the brand new books I just purchased. I am standing there thinking, "Okay, these books are now my property, and the guy just basically defaced it."
Since I was happy I got these books for a very good price, I didn't put up much of a fight, and the guy working at the register was extremely nice through and through. It just appears the business prodigies who run Borders and have successfully managed to run it into the ground also instructed their front line employees to make like Banksy on all sales. What is the logic here? My wife thinks it was to prevent resale, but how does that hurt Borders?
Anyone further interested in this subject should read “Assembly Language Step-by-Step” by Jeff Duntemann. Personally I consider it the best book on x86 assembly that I’ve ever read.
Yes, there is a lot of growth for Linux administrators.
I can't speak for the LPIC but you should get The Linux Bible and The Linux Command Line and Shell Scripting Bible and work through those. Then take the RHCSA and RHCE.
The Linux Bible
Linux Command Line and Shell Scripting
I don't know where you're located where junior administration can't lead into auditing or information security but you should build a lab and start building that knowledge and gaining experience. Chris Sanders has great books on the subject and an amazing website.
http://chrissanders.org/
He uses Linux for network monitoring and analysis.
There are also a slew of magazines and podcasts out there to keep you motivated, entertained, and educated. Jupiter Broadcasting is something I really enjoy. They took me from a Linux fan into an enthusiast into a professional. Linux Unplugged, Linux Action Show, TechSnap... Even the quirky BSD guys are awesome.
Linux Format is a great magazine, Admin is good, Linux Journal is hit or miss for me but it hits the spot when I'm looking for something off the wall or a project.
There are also subs on this site that are helpful and fun. /r/linuxadmin is interesting, /r/linuxmasterrace is GOAT, /r/linux is... Linux... /r/gentoo is beardly, /r/archlinux is -- READ THE WIKI.
If you get those books, which I can't recommend enough, start playing with Python too. Don't get Learn Python the Hard Way, get something like Python Crash Course which is significantly better. Your mileage may vary, this is just my opinion.
Good luck! Best thing to do is get a distro and start learning. Read the man pages/wikis, and then post a question. That will help you a lot in the coming days ;)
The Linux Documentation Project is a really good resource.
http://www.tldp.org/
http://www.tldp.org/guides.html
Another good way, start learning shell scripting:
http://www.tldp.org/LDP/Bash-Beginners-Guide/html/index.html
http://www.tldp.org/LDP/abs/html/index.html
http://www.amazon.com/books/dp/1118004426
Three books I have been using:
The Definitive Guide to How Computers Do Math
Web page here: http://www.diycalculator.com/
Assembly Language Step-by-Step: Programming with Linux
Hacking: The Art of Exploitation, 2nd Edition
The first uses a virtual machine running on Windows, with 5 registers, 65K of virtual memory, a debugger, and will give you a good basic understanding of what is going on. The second book uses Intel X86 on Linux, and gives a solid foundation of the most used instructions. The third book is just good.
Other favorites of mine include "The Art of Debugging" by Norm Matloff (google for his excellent web page) and "Professional Assembly Language" by Richard Blum.
Have fun!
I actually already have a copy of Hacking: The Art of Exploitation. My personal library consists of around 45 books on a range of computing topics from PHP, MySQL, C++, Windows Internals, CCNA, MCSE/MCSA, Unix, Rootkits, AI, Data Structures and the list goes on.
Other relevant titles include Gray Hat Python, Reversing: Secrets of Reverse Engineering and Rootkits: Subverting the Windows Kernel.
I was going to buy the following: Assembly Language Step-by-step, SQL Injection Attacks and Defense and Metasploit: The Penetration Tester's Guide.
I agree that where one starts really depends on what they want to end up doing. "Hacking" is such a general term and SQL-Injections is completely different from finding 0-days. If I'm honest I'm not sure where to start but I'm open to suggestions.
​
For me, "Minimal Perl" finally pulled together a lot of tricks for using Perl in a way that really cut out a lot of its book keeping code so I could get things done in a cleaner way. These are things I probably could have figured out on my own, but like with so many things, maybe being able to do it on my own versus having someone else actually do it makes all the difference in the world.
Link: http://www.amazon.com/Minimal-Perl-UNIX-Linux-People/dp/1932394508
It's funny because I just covered this while reading Linux Core Kernel Commentary. The reason that the linux kernel does it is performance. Instead of calling a function and having the, albiet small, overhead they use a goto. This is the only time I've seen goto's used as well, but the explanation makes sense.
Rust is a pretty high level language if you're trying to learn assembly and/or shellcode. You might be better off writing C and compiling with no optimization and looking at what's generated with the -S flag, or just no optimization and using objdump or radare2 to disassemble it.
If you want to learn low level linux stuff I highly recommend this awesome book available as a free PDF, the Linux Programming Interface. It goes into very deep detail and has example C code in it. Over a thousand awesome pages. I read through most of it except for the pseudo-terminal stuff because that is confusing as all hell. Another great book is "Introduction to 64 Bit Intel Assembly Language Programming for Linux" (Amazon.com), and you also might want to pick up a newer Instruction Set Reference for intel processors.
You also might take a look at MSFvenom and look at the encoder modules.
Indeed, I know, and perhaps I'm being overly snarky about it as I am tired & cranky today.
I was hoping there'd be a rough equivalent to Robert Loves Linux Kernel Development - a more accessible entry point than just diving into the official documentation without much of a roadmap
Assembly Language Step By Step: Programming In Linux
Jos haluaa käyttää ja konffata linuxia ja apuohjelmia sujuvasti komentoriviltä niin Linux Command Line and Shell Scripting Bible. Jos haluaa aloittaa perehtymisen siihen miten kerneli toimii ja miten sitä voi itsekin sorkkia, niin ensimmäinen kurssi on käyttöjärjestelmät ja kirjaksi joku Operating systems niminen oppikirja.
10000 limit again. Reserving this comment for the Programming section:
PROGRAMMING
Gray Hat Python: Python Programming for Hackers and Reverse Engineers
Beginning Python
The Python Standard Library by Example (Developer's Library)
Shell Scripting
Shell Scripting Recipes: A Problem-Solution Approach
Linux Command Line and Shell Scripting Bible, Second Edition
Wicked Cool Shell Scripts
sed & awk (2nd Edition)
The Ruby Programming Language
Beginning Ruby: From Novice to Professional
Ruby on Rails 3 Tutorial: Learn Rails by Example
Agile Web Development with Rails
Automating Microsoft Windows Server 2008 R2 with Windows PowerShell 2.0
Pragmatic Guide to Subversion
Programming Perl
C++ Primer Plus
The AWK Programming Language thanks sjhill
Modern Perl thanks three18ti
High-Order Perl thanks three18ti
The Art of Scalability thanks mr_chip
Scalability Rules thanks mr_chip
Continuous Delivery thanks mr_chip
The Varnish Book thanks mr_chip
I am a beginner too and just finished this book TLCL.Another one i would recommend is shell scripting bible.For most part use google to learn about commands and man page is your friend. I am more of a book kind of guy so never used video resources. Most important you should know where to look for help when stuck.
Knowing C++ in the field of Linux administration might help you when you need to debug or compile a library or application that is written in C++, and sometime you need to.
knowing C++ well can benefit you programming skills a lot, as lots of important software in the world written in this language.
Here's a good book.
http://www.amazon.com/Advanced-Linux-Programming-CodeSourcery/dp/0735710430
If you wish to really improve you Linux administration skills i would go for BASH:
http://www.amazon.com/Linux-Command-Shell-Scripting-Bible/dp/047025128X
Apple actively discourages people from avoiding their frameworks and linked libraries; there is a reason things like MUSL and µClibc don't exist on OS X. System calls on OS X do change signature without warning, so what's the point? You can't get at the system without using a dynamically linked standard library or keeping to a very small set of [so far] stable system calls like 'open'. Similar problem as Windows and its ever-present DLLs.
The one area where assembly is nice on Mac is in optimization within a C, Pascal, etc program. Because the ISA is x86-64 nowadays, if you don't care about supporting older PPC or x86 archs, you can have a lot of fun doing SIMD code. More fun than in Linux or even Windows? Not really; it's the same thing effectively (in fact, your code will be portable). If you like the platform for user reasons then it's a fine place to start and there's a decent recent introductory book about x86-64 assembly on OS X (and Linux): https://www.amazon.com/Introduction-Bit-Assembly-Programming-Linux/dp/1484921909/ref=sr_1_1?s=books&ie=UTF8&qid=1498145217&sr=1-1
But writing pure assembly programs in OS X basically has no benefit outside of educational ones compared with mixed C and assembly.
I'd recommend this book. Its on linux, which IMHO I think has a simpler api than windows.
About compiler generated assembly - compilers are evil wizards. The assembly they generate will look weird, mainly because it is, and wthat won't realy help you learn assembly.
xargs
sed
grep
awk
tail -f
find
less
vi
ls
wc
pwd
cat
blkid
lsblk
df -h
if/for/while/case
piping with |
There are really too many to list; I'd highly recommend checking out A Practical Guide to Linux Commands, Editors, and Shell Programming (3rd Edition) by Mark Sobell. It got me started on working from the command line and helped me move from a Help Desk position to a Sysadmin job a few years ago.
If you'll be working with AWS definitely check out their CLI documentation
This book does a pretty good job of introducing you to a lot of aspects of the wide world of Linux computing. I recommend it along with Ubuntu starting out.
EDIT: Removed referral code that I didn't put there.
If you're lucky, when your own curiosity brings you there.
I taught myself assembly using this textbook, and a copy of Intel's x86 instruction manual, over the summer after graduating college. Java was the language of choice for the C.S. program at my university. C was used in the OS and some computer graphics classes (others used Java 3D), but everything else was high-level, no memory management, with a virtual machine and garbage collector to wipe my ass and feed me crackers. (Here's a very recently published book.)
In my experience, learning assembly helped me gain a deep understanding of how programming works. With a 1-to-1 (almost always) mapping between a line of assembly and a CPU instruction, I felt like I was directly instructing the computer in a way I never feel using high-level languages. From that, I gained an appreciation of how low-level C programming can be, because you can see immediately how C statements are transformed into assembly. After learning assembly, I deliberately compiled programs into assembler with GCC so I could look at the code, because I could finally understand it.
And then I learned C++, and saw how it could be built directly on top of C.
And now it all makes sense.
I didn't say that I just said you be the judge. I also prefer debian.
Here this is written by the same guy for ubuntu in 2012.
Sure thing! I completely understand the frustration. Setting up config files seems antiquated...but there are a few very nice things about them.
The more time you spend with Linux, the more familiar the language will become. Remember that you didn't always speak English (or whatever your native tongue is), but now you can typically do it without thinking. Linux is very similar in that once you learn the words and flags you want to use, it will seem simple.
If you're looking for a good book to get you started, I can't recommend this one enough: A Practical Guide to Linux: Commands, Editors, and Shell Programming. Here's my description of it from another l4n post:
It's a great book for a beginner who doesn't want to get a Dummies book that is mostly concerned with the GUI and doing all the same things that you would on Windows or Mac OS, but instead wants to learn about what you can do without a GUI. It's a great reference book as well, containing the man pages for many commonly used and built-in commands. If you're not sure what the man(ual) pages are, they're one of your best resources for information about (most) any command on your system. "man man", in addition to being a great band, is a command that you can run to find out more about the man pages. For a good example that shouldn't overwhelm you, run the command "man cp" and see what all the options for the copy command are. A good way I've heard the man pages explained is that it will not tell you how to use a command, but it tells you the things a command can do. How you use it is up to you!
Also, I (shamefully) have not done this completely, but if you want to learn about how the core of most any Linux system works, install Arch using their fabulously laid out Beginners Guide
Suggested in a related thread I was able to learn enough to read and write it better from this book: https://www.amazon.com/Introduction-Bit-Assembly-Programming-Linux/dp/1484921909/
Even better beyond is to write some C and observe what GCC or Clang compiles it into, and see if you can mentally (or actually) map the disassembly back to C.
It's called Understanding Unix/Linx Programming: A Guide to Theory and Practice
If you're into paper:
Duntemann's book uses Linux and flat address space in the third edition.
Oh. In that case I'm not sure what the definitive ones are but any of *these should give you a good idea.
/u/The_frozen_one linked you to IDA, which is pretty deffacto in the reversing world. The free version is limited, though, so if it doesn't quite give you what you need and you want to save money, Visual Studio's debugger has a pretty decent disassembler.
Learning how to read assembly is kind of challenging at first. Something I'd recommend looking into to pair with your journey is Jeff Dunteman's Assembly Step-by-step.
It uses Linux as its teaching OS, so a few things on Windows will be different, such as syscalls or anything ABI specific.
That said, it uses Intel syntax which is what you want, and it has several hundred pages of reading before a hello world is even written. Even if you choose not to continue reading after that, those few hundred pages alone make the book worth buying.
Ah yes, well that would be a mix of reading the first couple chapters of this book: A Practical Guide to Linux , and experimenting.
Edit: Replaced the mobile link.
Introduction to 64 Bit Intel Assembly Language Programming for Linux: Second Edition by Benjamin Ray Seyfarth It goes over the basics of assembly, is pretty much up to date and the e-book version is only $5
I recommend this book for x86-64 Linux based assembly. https://www.amazon.com/Introduction-Bit-Assembly-Programming-Linux/dp/1484921909/ref=sr_1_1?ie=UTF8&qid=1517846307&sr=8-1&keywords=ray+seyfarth
i would recommend this book.
Pick up any book on x86 assembler. You cannot program assembler without understanding the underlying system architecture, and as such most books on assembly language will include a deep dive on x86 architecture from the programmers perspective.
Assembly Language Step by Step by Jeff Duntemann: https://www.amazon.com/Assembly-Language-Step-Step-Programming/dp/0470497025
This is one of my favorites, the first assembly book I was able to make it all the way through. Once you do, I also highly recommend
Modern x86 Assembly Language Programming by Daniel Kusswurm: https://www.amazon.com/Modern-X86-Assembly-Language-Programming/dp/1484200659
A very thorough, yet surprisingly readable, dive into thw inner workings of thw advanced x86 feature sets, like MMX and AVX.
I highly recommend this book given your specific skill set.
Minimal Perl: For Unix and Linux People
An earlier edition of this book was my text in college. Super handy book, I keep it on my desk at work to this day. The newer version was even reviewed on Slashdot.
I am reading the first edition now and it is really good so it can't hurt. It is a great into, and a good reference even for people who know what they are doing.
I am also reading this for school as well http://www.amazon.com/Practical-Guide-Fedora-Enterprise-Edition/dp/0133477436/ref=pd_sim_14_2?ie=UTF8&dpID=517h5KJOQVL&dpSrc=sims&preST=_AC_UL160_SR129%2C160_&refRID=0T274B6GDEYV9EQ9WGSG but I hear http://www.amazon.com/Practical-Commands-Editors-Programming-Edition/dp/013308504X isn't bad either
http://www.amazon.com/Linux-System-Administration-Handbook-Edition/dp/0131480057/ref=wl_it_dp_o_piT1_nS_nC?ie=UTF8&colid=12MNX8P4AJLZY&coliid=I3AKRESKO8PAOP
http://www.amazon.com/Practical-Commands-Editors-Programming-Edition/dp/013308504X/ref=wl_it_dp_o_pdT1_nS_nC?ie=UTF8&colid=12MNX8P4AJLZY&coliid=I2HFBSVXDY6AFF
http://www.amazon.com/RHCSA-Linux-Certification-Study-Edition/dp/0071765654/ref=wl_it_dp_o_piT1_nS_nC?ie=UTF8&colid=12MNX8P4AJLZY&coliid=I2P3ILHN0013L1
http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668/ref=wl_it_dp_o_pdT1_nS_nC?ie=UTF8&colid=12MNX8P4AJLZY&coliid=I3H6KNRFYQI1QC
I'm using the following book to learn Assembly and really liking it so far.
http://www.amazon.com/Assembly-Language-Step-Step-Programming/dp/0470497025
It goes into C at the end. I chose to learn Assembly because I wanted to learn how it all works behind the scenes a bit more. I think it's definitely worth the time to go through and will lead to your goal of learning C.
Linux e-book is a very broad subject. Maybe I could make some recommendations if you wanted to narrow it down a bit?
edit: for a good "linux" book i've heard good things about Linux Programming By Example: The Fundamentals.
http://www.amazon.com/Linux-Programming-Example-The-Fundamentals/dp/0131429647/ref=pd_sim_b_7
Please look on this book
book
Learn to read x86 assembly and learn what a stack frame is. These two should make exploitation and shellcode both make sense (or at least way easier to understand a simple buffer overflow).
I used this book when learning assembly. I used it as a programming text though, comparing the differences between 32bit and 64bit x86 as I went. Lena's Reversing Tutorial also hits a lot of the basics.
I disagree.. you should definitely learn red hat/fedora/centos in terms of network configuration files, other config files etc etc if you want to have a good knowledge of server level/enterprise level linux. Red-hat based distros are MUCH more widely used for server implementations than debian or slackware.. But that said definitely learn the debian way too. Linux in a Nutshell is a good back, or this book is also quite good: http://www.amazon.com/Practical-Guide-Commands-Editors-Programming/dp/0131478230/ref=sr_1_16?ie=UTF8&s=books&qid=1250956616&sr=8-16 -- Another good one is the Linux Quick-Fix Notebook- excellent excellent book
If you are willing to spend a little money, I'd suggest the Linux Command Line and Shell Scripting Bible. It will first teach you about the commands you can use on the CLI. Then it will delve into shell scripting. After finishing that book up you should have a very decent understanding of bash.
Another good tutorial that I can Recommend is The Linux Command Line. There are free lessons on the website that cover the same material as his book does. The book is just a lot more in depth.
Also, after you gain some familiarity you can try reading through the bash man page. It's a heavy read, but you can definitely learn a lot from it.
Good luck!
I don't recommend either of those books, try these instead:
High Performance MySQL: Optimization, Backups, and Replication by Baron Schwartz, http://amzn.com/1449314287
A Practical Guide to Linux Commands, Editors, and Shell Programming (3rd Edition) by Mark G. Sobell, http://amzn.com/013308504X
Shit, sorry for not replying sooner, I just saw this response - I don't check on here very much.
Thanks for the reply, I'd given up on this thread. I'll look into those resources you mention. The target OS is Linux, so that makes things a bit simpler i guess.
Do you have any opinion on the relative merits of these 3 driver books: (I've heard the bottom one 'Essential Linux Device Drivers' is getting a bit old now (targets a fairly old kernel) but I don't know if that matters
I just saw you said low on funds, but if you have a birthday or something coming up these two books have been great resources for me, and others that have taken a dive into it.
https://www.amazon.com/Linux-Bible-Christopher-Negus/dp/111821854X
https://www.amazon.com/Linux-Command-Shell-Scripting-Bible/dp/111898384X/ref=pd_sbs_14_img_1?_encoding=UTF8&psc=1&refRID=J9RW2JJ25KF0HEW2DDNK
One thing I'd say is DON'T BE DISCOURAGED. There's a lot to Linux, and it'll feel like you are drinking through a fire hose sometimes with concepts, everyone has been there, and I'm still very much there. In addition to reading a butt load, one thing that helped me take the edge of was getting a box up with something I'd use. My personal pet project back in the day was setting up a redhat instance and run a ventrilo server. It helped me learn things like security, package management, patching, getting real comfortable with things like awk and sed. I didn't expose it to the internet except for a few whitelisted IPs but it kept me learning for a long time, and made it fun.
This book is a pretty good place to start.
Hey, no problem man. The source for this particular script is kind of mediocre, but it is here. Note that I included a file called "wow," to get the shell to respond when I typed "wow, real mature, shell".
I want to also mention that when I was learning shell scripting, I made a shell script with a ton of comments to help me understand stuff better. That is located here. And also, for fun, here is a shell script I wrote to make the mouse pointer touch every pixel on your screen. For further learning, I really can't reccommend Mark Sobell's "A Practical Guide to Linux Commands, Editors, and Shell Programming (3rd Edition)" highly enough. It really brought my practical Linux knowledge to a much higher level. I think you can Google that book and get the 2nd edition in pdf form somewhere.
That was a very interesting introduction into Assembly. Thank you a thousand times! That being said -- hopefully the latest addition of Introduction To 64-Bit Intel Assembly Language Programming for Linux is just as good, because I am not paying $377.81 for a copy of the edition found on your link.
I'm always extremely impressed when I see people creating substantial programs (Roller Coaster Tycoon!) in Assembly. But I think it would just be a lot of fun to create smaller programs in it, as a way of learning various operating system principles in greater detail.
So, again, thank you so much for taking the time to write up that introduction. I greatly appreciate it!
I can't recommend this enough. It's about as comprehensive a guide to Linux as you could hope for, and accessible for beginners.
As far as distros go, I'd go with Mint. It's a great community-driven distro that's very user friendly.
A good book on the subject of command line programs is Linux Programming By Example.
A good site on sdl and basic graphical programming for linux is: Lazyfoo. Of course, OpenGL is another choice, and programming in OpenGL is basically the same cross platform.
The best book if you plan to start working on the kernel (in my opinion) is actually the Device Driver Book, but people also really like the Understanding the Linux Kernel book.
Obviously the other option is just looking for good tutorials online, for that you need:
gcctutorialCtutorialmaketutorialgdbanddddtutorialOf course there's also Qt which is used by a lot of people.
Here is the book had had us use. Pay careful attention to the sed, awk, and perl sections. There's a ton you can do with perl, and Maynard is very specific on what he wants everyone to focus on. He'll give you a tiny packet on what you'll need to know. The low level C part is pretty crazy, but he'll give you enough rope to hang yourself.
You will be writing programs for the tests. It will range from writing a script, to writing a function, to writing an entire program. It's hard to describe Maynard, honestly. For instance, on one of my tests I switched my dup2() statements effectively switching input/output. He took off 10 points out of 25. On certain topics he'll want to make a point and be very heavy handed with the grading. The programs especially.
The good news is that all of the quizzes, programs, and tests really don't matter. The final does. I got an 82 on the first test, 42 on the second, and subpar on all the programs. Got an A in the class because I beasted the final. As long as you dedicate 50% of your time that semester to Systems, and the rest of the time for everything else, you'll do fine.
If you really want to learn from the ground up, that is to say low level to high level, I'd recommend starting with Assembly Language Step-By-Step. It will get you introduced to binary computation, binary math, and x86 assembly. From there, I'd say move on to The C Programming Language, AKA K&R.
After that, if you've stuck with it and still enjoy it; the coding world is your oyster. Build something brilliant and reap the satisfaction of building your own programs.
Good luck!
If I were you, I'd go ahead and start with Assembly Language: Step by Step (Programming with Linux) it's not really what you are asking for but it will show you how to write assembly language (thus showing you how C really works), it will show you how the Linux API works at the lowest levels and interfacing with Linux/The Standard C Library.
Pick up K&R while you're at it despite your claim it's not recent; it's a good reference. Once you can write some simple assembly programs, rewrite them in C. Then do something that mixes the two (like write your own functions in assembly and then use C for program flow.)
After that, write a bootloader and boot Linux (they aren't as hard as you think if you aren't trying to rewrite grub). Once you can boot Linux, write your own (very simply) hello world multiboot kernel. Use that bootloader to jump to it. Add a keyboard and screen driver to it (again not as hard as you think just to do basic stuff.) Then play around with your hardware (hard disks is a good starting point) and learn how to interface with them at a bare-bones level (since your interested in audio how about trying to send out simple sounds to your onboard sound using your own kernel.)
At that point your problem with C will be gone and you will be comfortable writing kernel code. Some people might talk down on this answer but with what you want to do it's worth toughing it out if you want to quickly get comfortable with C and kernels (you might have a few days of doubt though friend, suck it up!)
At this point find a project (ALSA/Pulseaudio) and start fixing bugs for them (there is usually a ridiculously easy list of bugs on larger projects that will help get you used to the codebase.) At the same time get the Linux source and write some basic modules, while also attempting to fix some of the kernels super easy bugs. After a year or so of doing that you should not only be good with the programming aspect (and you'll know how to learn codebases as well) you will also learn a lot about how the FOSS community works (and the do's and don'ts of commiting to projects.)
Best of luck!
edit here's a link to the book
https://www.amazon.com/Assembly-Language-Step-Step-Programming/dp/0470497025
we're using this book in my assembly/c class. according to my professor the writer was a sci-fi novelist so the book is a story and it involves aliens. http://www.amazon.com/Assembly-Language-Step-Step-Programming/dp/0470497025
edit: important to note that the author treats assembly as the first computer language you've ever learned so if you start from the beginning it will cover the absolute basics
https://www.amazon.com/dp/111898384X/ref=pd_lpo_sbs_dp_ss_1?pf_rd_p=1944687582&pf_rd_s=lpo-top-stripe-1&pf_rd_t=201&pf_rd_i=1118004426&pf_rd_m=ATVPDKIKX0DER&pf_rd_r=01KPPR73M7GZMDV2ZTYJ
^^ Grabs Copy of the Linux Command Line and Shell Bible 3rd Edition
Understanding Unix/Linux Programming has as one of its projects an implementation of pong using ncurses and interrupts.
This book is how I first learned. https://www.amazon.com/Practical-Guide-Commands-Editors-Programming/dp/013308504X
I really love this book, has tons of great info in it. Might be able to find it online somewhere.
https://www.amazon.com/Linux-Command-Shell-Scripting-Bible/dp/111898384X/ref=pd_lpo_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=KDKCH1GWS30M5R9G2Z3A
Otherwise, come up with a simple task you want to accomplish, and try and break it down into small steps. Then do some reading on basic bash commands and try and piece it together from there!
Read Books: I recommend this, this and this.
https://www.amazon.com/Practical-Guide-Commands-Editors-Programming/dp/013308504X
Then you probably want this.
Thanks for steering me away from that. I'll check out that list from /u/va_network_nerd. I've currently been going through a book by Mark Sobel here
Seems good so far, but I'm only a few chapters in.
The class is intro to Linux so we don't work with a specific language but here is the book.
This is a vast topic and I don't think you will find something to cover all the subjects at once.
To understand how the processor works this video does a really good job in explaining most of the essential stuff.
I also suggest you try to get your hands dirty with some assembly language so you get the feel of it. I liked Assembly Language Step-by-Step book.
There is also The Hardware/Software Interface course. This will give you a great starting point in digging deeper into the subject.
>shell prompt
If you have money, this one is a good option
These two are good and available for free, I suggest you start with them.
> administration
This one is the best.
C, C++, Assembly are best suited for the purpose. For managed code rootktis part, learn Java and/or .NET.
For Linux programming, have a look at (http://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=sr_1_1?s=books&ie=UTF8&qid=1450511098&sr=1-1&keywords=LINUX+Programming). In fact, this is a must read book IMHO. Apart from this, you can try these too:
EDIT: Formatting
Check out this Crash Course series, it's quite informative: https://www.youtube.com/watch?v=O5nskjZ_GoI.
If you want to go deeper, check out some of the free Computer Architecture courses on the Internets.
Alternatively, if you want to be a Linux/Windows power user, there are some good books out there, like this.
You can try giving this book a shot. I took 271 on the Cascades campus and we used that book plus this book. The first is free and I thought was useful, a bit quirky but good info.
I'm a Windows admin who wanted to learn more Linux. I asked a friend the same question as you recently. He recommended A Practical Guide to Commands, Editors and Shell Programming by Marc Sobell as well as Web Operations by John Allspaw and Continuous Delivery by Jez Humble. He recommended I start with Sobell's book before moving on to the others.
:/ I haven't had much time to actually read any of this, but I trust his advice.
Minimal Perl is a highly recommended book for learning Perl.
I recommend you pick an architecture that you can work in and see somewhat immediate results from; x86 is a good idea because it's very well supported and just about every question about it has been answered somewhere. You'll probably be working on a simulator otherwise, in which case you can run into all sorts of other fun problems, and you'll likely end up learning stuff that doesn't apply too terribly well to how things are actually done in the wild.
Dialect-wise: If you're doing standalone assembly or something for use only on Windows/DOS platforms, then NASM or MASM is your best bet. If you want your assembly code to interface more closely with, or be embedded inline within C code in anything remotely resembly a GNU compiler (including GCC, ICC, and Clang, most notably), then GAS is your best bet.
As was mentioned, GAS uses a different syntax from Intel's standard one (different operand orderings, different mnemonics, pretty much everything's different for some fucked-up reason) so you'll see mostly NASM/Intel-like syntax in plaintext (tutorials and the like) on the Web and GAS in source code.
Can't recommend you towards any good resources, although when I was a wee bairn I learned 16-bit x86 assembly from Jeff Duntemann's book (16-bit DOS version, which you can use in DOSBOX or a run of DOS's DEBUG; 32-bit Linux version, which you can use in 32- or 64-bit Linux provided you use the
-m32flag to compile). NASM's manual may still have a decent instruction reference in it (check for older versions, because it was quit handy), and Intel's Software Developer's Manuals are the go-to reference for their backwards-compatible shitheap of an ISA once you're familiar with it.laptop huh what when i went to school for cs we used punchcards....
but in all seriousness, writing code is about the equivalent of writing text in a text editor. get something w/ decent battery life and comfortable screen size; any modern machine is likely more than enough to run and test all or most assignments from CS courses, save some specialized topics, in which case the univ. probably provides resources you'll need.
what matters more than the hardware is the environment you work in. do yourself a favor, wipe out windows and put a linux distro on it (or dual boot, you big sissy!!); start with ubuntu or fedora if you're new to linux, and deep dive in. force yourself into the command line. A Practical Guide to Linux from Mark Sobell is an EXCELLENT book for learning raw, distro agnostic Linux from the command line/shell perspective (http://www.amazon.com/books/dp/013308504X I have the 2nd edition, I'm sure the 3rd is great).
Learning how to truly use a computer and work w/ the operating system instead of around it is crucial, esp. if you want to go into engineering as you mentioned below. I won't rant any further but when you get into industry you'll be glad you have practical experience w/ *nix operating systems. As far as school goes, it will increase your productivity and workflow, as linux/unix is the environment developed by programmers for programmers to do productive programming first and foremost, and is generally better at everything else too.
-a CS graduate researcher/cloud-computing engineer/full stack developer
Try reading http://www.plantation-productions.com/Webster/www.artofasm.com/index.html
Also, im assuming that you want to learn about the PC, as in, IBM PC & Compatibles which is every modern home computer including Apple computers. You will probably want to read the IBM PC Technical Reference manuals to learn some details.
If you want to learn about a different system then you just need to look up books and reference manuals for that system.
If you want more generic information, then you might want to look for electronics book that teach how a computer works or how to design your own.
EDIT: Also, try this book out: https://www.amazon.com/gp/product/0470497025/ref=dbs_a_def_rwt_bibl_vppi_i0
It teaches x86 assembly as your first language and it covers what you probably need.
There are 3 editions. I've linked the newest, but the 2 edition before it cover 16 bit real mode DOS as well, which might be easier in some ways.
+1 for devops. Anyone looking for a reference manual for Linux should check out Mark Sobell's books. Really useful and doesn't become obsolete after a year (or even 10 years!). Just got his 3rd edition Linux manual for Christmas and I'm ecstatic.
I don't think there really needs to be any specifics here. A book I read that really pushed me along when I first started was a book about web developing with php and MySQL. It wasn't that great of a book and I'll probably never touch it again, but it pushed me further than any article I read at the time. Another was Understanding Unix/Linux Programming. It's extremely expensive so I'd be weary about actually recommending it, but it was required text for a college class (one of the better college recommended books I've had to buy). However, that book mainly just succeeded in making me proficiant with man pages.
There's been books that when I first start reading them it really makes the subject matter click and I never end up finishing them because the documentation is more than what I need at that point. I think that's why you'll read some reviews on programming books that range from it being extremely helpful to worst book ever made.
I think that was the point of the tip. If you're learning something, just pick up a book that deals with the subject. It'll set you in the right direction and help you overcome any anxiety when starting something that at first glance, seems complex. It also forces you to read from start to finish rather than glancing over a blog post that might have the information you need.
Results may vary.
Yes, there are actually .exe files, both cd and ls as well as most every other command.
Edit: In fact, just earlier this year, I purchased this book which deals with exactly what you're talking about. The examples in the book go through *nix commands that you study, then re-implement yourself in C. You should take a look at it (there might be copies at that site down by the bay wink wink.)
http://www.amazon.com/gp/product/0130083968/ref=oh_details_o03_s00_i00