(Part 3) Reddit mentions: The best operating systems books

A few of my favorite books I reference and recommend. Just a note, many of these are older and can be purchased used for much less. Also if you can afford it, get a Safari subscription. I use my work Safari subscription but this alone has saved me from my book buying habit. Now I only buy "must have" books. :)

Official Ubuntu Server book - I really like this book as the writing style helped me "get it" with Linux. Kyle Rankin has a very good method of showing you the technology and then a quick run down to get the server working, followed by some admin tips. It's a just scratching the surface type of book but it's enough to get you started. I rarely use Ubuntu now, but this book helped me understand DNS and other topics that were IMHO harder to grasp from other books.

As a bonus, this book also has an entire chapter dedicated to troubleshooting. While this sounds obvious, it's a great read as it talks about dividing the problem, how to approach the facts, etc. Stuff a seasoned admin would know but might be hard to explain to a new admin.

The Linux Command Line: A Complete Introduction - You can read this book for free on the site, but having a paper copy is nice. As mentioned, you should have a very solid understanding of the command line. In my experience, I have seen co-workers struggle with basic shell scripting and even understanding how to make a single line for loop. This book covers the basics, moving to shell scripting and I think it's a good solid reference guide as well.

DevOps Troubleshooting: Linux Server Best Practices - This book is referenced a few times here but I'll throw another comment for it. Another book from Kyle Rankin and has the same straight to the point writing style. It's very quick reference and simple enough that you could give this to a new sysadmin and he or she could get started with some of the basic tools. While the book covers a good selection of basic services and tools, it's easy to get deeper into a chapter and find it's only discussing a handful of troubleshooting steps. The idea with this book is it's a quick reference guide, and if you want to get deeper into troubleshooting or performance, take a look at other books on the market. Either way, this is a great book I keep on my desk or reference through Safari.

UNIX and Linux System Administration Handbook (4th Edition) - Another popular book based on the comments here. This is a pretty big book, thin pages, but it's like a small brick of UNIX/Linux knowledge. While it's starting to get dated, it does give a great reference to many topics in the system administration world. The chapters can dive deep into the subject and offer more than enough information to get started but also understand the technology. The e-mail chapter I thought was great as well as the DNS. I think of this book as a overall guide and if I want to know more, I would read a book just on the subject, that's if I need more information. One thing to point out is this book makes use of different OS's so it's filled with references to Solaris, different UNIX versions, etc. Not a problem but just keep in mind the author may be talking about something outside the scope of vanilla Linux.

Shell Scripting: Expert Recipes for Linux, Bash and more - I found this book to be a good extenstion of the Linux Command Line book, but there are many many other Bash/Shell scripting books out there. The author has many of the topics discussed on his site but the book is a good reference for scripting. I can't stress enough how important shell scripting is. While it's good to know a more formal language like Python/Perl/etc, you are almost certain bash will be on the machine you are working on.

Systems Performance: Enterprise and the Cloud - I can't comment on this book beyond the first chapter, I'm still reading it now but it's reading similar to Brendan Gregg's site, and that's a great thing. If you don't know who this guy is, he's one of the top performance guys in the Solaris and now Linux world. He has some great infographics on his site, which I use for reference.

Use method for Linux

Linux Performance

Example of Linux performance monitoring tools

Hope this helps!

>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.

Hey,

I assume you have good grasp about the culture and ecosystem you want to work in by now. This means you're in a perfect situation to dig deeper.

My first advice would be to be more specific in your goal. Find a project which is interesting to you. This will help you to cut down the list of "things to learn", as you will concentrate on the tools the project uses.

In your tool belt should be at least:

• 1. a programming language (including how to use the compiler, debugger)
     
     
• 2. a build system suitable for the language
     
     
• 3. a version control system
     
     
• 4. a understanding for the platform you write code against
     
     Suitable answers can be:
     
     
• 1. C , GCC and GDB
     
     
• 2. GNU Make; as Cmake and Autotools generate Makefiles it is good to know the basics; it is mighty enough to support medium sized projects
     
     
• 3. Git is what the cool kids use
     
     
• 4. Linux and it's system calls / POSIX; your libc implementation
     
     This list is enough to keep you busy for a year easily.
     
     Here is a list of recommendations of resources which proved invaluable for me (based on the list above and more; this list contains free web resources and books):
     
     
• 1. "The C programming Language", in my eyes the best book on C and pointers. It biggest drawback that it's a bit dated. Have a look at the different C standards (like C99/C11 etc) and look up whats new. Reference sites like this will normally mark features of newer versions. Read them for fun. For a more in depth look at pointers see Understanding and Using C Pointers. The different compiler options made sense to me first when I started to learn Make, this will come with time. No real recommendations for the debugger thou. I've learned by searching on the internet / documentation.
     
     
• 2. the GNU Make manual is a great resource. But consider to have a look at Managing Projects with GNU Make, Third Edition which has a more practical approach and explains how to manage bigger projects.
     
     
• 3. There is nothing better than the official Git Book. It covers everything, if something breaks your best bet is normally stackoverflow.
     Learn about GitFlow and the arguments against it. Write good commit messages. Understand different versioning schemes (https://semver.org/ ; http://calver.org/ ).
     
     
• 4. man-pages, learn to love them (they deserve it). Where man-pages fall short is a clear explanation on why you might want to use an interface over the other. The best resource to fill this gap I found is The Linux Programming Interface. It covers nearly everything the operating system offers you, including background information. But you might want to get the e-book version as it is quite large/hard to search in paper. Getting to know your libc implementation, normally glibc, and its extensions is also important. Another good resource for some topics is Advanced Unix Programing, but it's clearly on the "further reading" list. Read it if you want to learn about "pseudo terminals" and how to be portable with other "Unixes".
     
     
• 5. Misc: learn how to use the doxygen documentation tool
     
     
• 6. As you mentioned in another comment that your goal is to work with the kernel directly: Linux Device Drivers is old, like grandpa old. But the core concepts it teaches still apply today.
     Unfortunately, apart from it, good resources on kernel programing are sparse. After working through this book your best bet are the drivers in mainline, the kernel documentation and google. Have a look at kernelnewbies for an introduction on how to get involved with mainline.
     
     
• 7. Have a look at buildroot for an "easy" way to build custom systems for Qemu or your rasberrypi. Yocto is an alternative but can be quite intimidating starting out.
     
     Regarding your ideal schedule: I cannot answer this to be honest.
     
     /Rambling ahead/
     
     But: find a hobby project (e.g. implement a Z-machine) you want to realize in "a professional manner".
     What I mean by that is, strive to use all the tools you want to learn in a disciplined manner. Put your project out there on a public git host and assume you have real users who want to build your stuff on their own machines. Treat this project as your business card, don't be afraid but improve it constantly.
     
     There is always something you didn't know. You will always find things to improve, even it's only a improvement from a purist standpoint. But your "hobby" project is not done as soon as it works. It's a test bed, a record of what you've learned. It is a reference point for the future you to come back.
     
     Read blogs about development. Learn a object oriented language and see how you can apply these concepts in C (encapsulation, "object orientated design in C without classes"). Learn a functional language just to see something completely different (Haskell / a scheme / Common Lisp ). Realize that it's sometimes just a bad idea to use C for some projects / parts of a project.
     
     Consider to always learn the "core tool" first and then its "high level abstraction tool/helper". Eg: learn the basic usage of the gdb/git comandline tool before you dive into a graphical wrapper. Depending on your environment you wont have access to the wrapper, but the cli tool will be (hopefully) there. For example I use emacs (i know vim too) for git nowadays, but I'm not lost if I don't have access to it. Also it is always good to understand the core concepts.
     
     Read Linux Weekly News (access to the archive is free), have an eye on the Linux Kernel Mailing List. Bootlin.com has a ton of great learning material regarding embedded Linux, Driver programming, Yocto and buildroot.
     
     Don't be afraid to jump into an IRC channel / a mailing list, but be sure to do your homework first. They'll eat you alive if you didn't. (see http://www.catb.org/~esr/faqs/smart-questions.html)
     
     Be open but do your own research. Inform yourself on the pro and cons of everything. Don't believe in "silver bullets".
     
     It will be a steep learning curve in the beginning, but with every step you take it gets easier.
     
     Hope this helps you on your journey.
     
     Personal Info/Disclaimer: I'm a "professional" (i get paid) "embedded Linux" developer, writing system programs and kernel drivers for about 8 years. I still learn stuff every day. Recommendations are heavily based on my own experience and what I use still on a day to day basis. Regarding on what you want to do this list may lack information.
     
     edits: grammer, formatting, multiple additions in the first 2h

So these are complicated topics. I know more about the iOS side of things, but I'll try to point you towards some Android resources too.

For iOS, a good place to start would be to pick up an iPhone 4. It had fewer exploit mitigations and jailbreaking it was a lot easier. I highly recommend The iOS Hacker's Handbook. It's old, but the same basic concepts apply, especially for older versions of iOS. If you brick a newer iPhone and have to reinstall, you'll lose your jailbreak. With an iPhone 4, all installable versions of iOS are jailbreakable, so if you brick it you can always get back in. If you look at the iPhone Wiki you can see some writeups of some jailbreaks. Evasi0n 6 or 7 might be a good place to start. Get an iPhone 4 running iOS 6 or 7 and try to reimplement the kernel vulnerabilities used by them.

iOS and macOS share a lot of common code, and macOS is a much easier target since you can run it in a VM and it isn't as locked down. So that might be a good place to start to learn how to attack Apple's OSes. Here are some good walkthroughs of some macOS exploits:

• Pegasus Kernel Vulnerabilities
  
• Blitzard Kernel Vunerability
  
• Ian Beer's Project Zero macOS PoCs
  
• OSUnserializeBinary UAF
  
  @qwertyorioup on Twitter posts some interesting discussions and he has some good writeups on his blog. He also did a good presentation on attacking the xnu kernel.
  
  Jonathan Levin also has some good books on iOS and macOS internals, which you can find more about at his his website. He also has writeups on the TaiG jailbreaks.
  
  For Android, The Android Hacker's Handbook is pretty solid. Jonathan Levin also has an Android internals book here.
  
  I would recommend maybe picking up an Nexus 5. They're pretty cheap and easily rootable so you can hack around on them. Here are some writeups of Android/Linux kernel explotis that might be helpful:
  
  
• Exploitation of CVE-2016-0728
  
• Exploitation of CVE-2014-4322
  
• Linux kernel ROP example ... these guys have a few writeups as well.
  
  I also found this Android Kernel Exploitation Playground, but I have no idea if it's any good or not.
  
  Regardless, for all of this you need to know C and assembly. For iOS and Android, you need to know ARM, and for macOS you need to know Intel x86_64.
  
  Anyway, hope this helps!

Sure thing! I completely understand the frustration. Setting up config files seems antiquated...but there are a few very nice things about them.

1. You can reconfigure the files from any computer with ssh or putty available, and don't have to configure VNC or another screen sharing program to do it
   
   
2. Configuration files are simply text files, so if you need to do a reinstall you can simply back up the necessary files, reload the OS, and reload the configuration files. The more convoluted your setup, the more files you'll need to back up, but at least you know when you reload them your configuration is saved. While this is true of the %appdata% folder on Windows as well, it's still a nice perk I feel.
   
   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

Nand to Tetris (coursera)

the first half of the book is free. You read a chapter then you write programs that simulate hardware modules (like memory, ALU, registers, etc). It's pretty insightful for giving you a more rich understanding of how computers work. You could benefit from just the first half the book. The second half focuses more on building assemblers, compilers, and then a java-like programming language. From there, it has you build a small operating system that can run programs like Tetris.

Code: The Hidden Language of Hardware and Software

This book is incredibly well written. It's intended for a casual audience and will guide the reader to understanding how a microcontroller works, from the ground up. It's not a text book, which makes it even more more impressive.

Computer Networking Top Down Approach

one of the best written textbook I've read. Very clear and concise language. This will give you a pretty good understanding of modern-day networking. I appreciated that book is filled to the brim of references to other books and academic papers for a more detailed look at subtopics.

Operating System Design

A great OS book. It actually shows you the C code used to design and code the Xinu operating system. It's written by a Purdue professor. It offers both a top-down look, but backs everything up with C code, which really solidifies understanding. The Xinu source code can be run on emulators or real hardware for you to tweak (and the book encourages that!)

Digital Design Computer Architecture

another good "build a computer from the ground up" book. The strength of this book is that it gives you more background into how real-life circuits are built (it uses VHDL and Verilog), and provides a nice chapter on transistor design overview. A lot less casual than the Code book, but easily digestible for someone who appreciates this stuff. It culminates into designing and describing a microarchitecture to implement a MIPS microcontroller. The diagrams used in this book are really nice.

I learned the basics of Lisp from this
book, which you can get online for free. Although it's about Common Lisp you
can translate most of it easily to Elisp, just (require 'cl-lib) and you will
be fine. For another quicker but great introduction to Lisp I recommend
reading the first three chapters of
PAIP

The old Writing Gnu Emacs Extensions
still serves as a good introduction to learn Emacs APIs. I also learned a lot
more about Elisp reading nullprogram.

Reading code of small packages which solve something you are interested in is
another great way to further improve your Elisp skills.

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!

> It is a real Lisp and a good starting point

While not directly related, there are a lot of classic Common Lisp and Scheme books that while not explicitly the same as Emacs Lisp, wrinkle the readers brain in a way that is useful for coding in emacs lisp and becoming a better programmer in general IMO.

All of the texts I have read that are listed on A Scheme Bookshelf and A Lisp Bookshelf have been great reads; also they are excellent texts for reference on how to make great technical literature on par with Donald Knuth's books with respect to quality of presentation.

Writing GNU Emacs Extensions is still mostly relevant, despite its age, which IMO is a testament to how timeless Emacs is.

An Introduction to Emacs Lisp is great, and also included with every Emacs installation.

First step, learn Java well enough to be comfortable reading and writing it. You can check out the Java Tutorials to get started. Another good resource is Head First java. I'd recommend getting your head around Object Oriented Programming and writing some simple programs in plain Java before you dive into Android.

Next, check out the Android Documentation as it's going to become your best friend. They have loads of tutorials and sample code to help get you started. I also found The Busy Coder's Guide to Android Development and Professional Android Application Development really helpful and would definetly recommend reading a book on Android dev as it will make things a lot easier when debugging/coding. Android apps are quite different then desktop apps so it's worth understanding how they work and the ideas behind Android's design.

Finally, code up your app and launch it!

Depending on your exposure to exploitation in general, it may be best to briefly introduce yourself to exploitation on Linux first to learn the basics, as there are some additional complexities with Windows exploitation not present in Linux exploitation.

That said, here is a great course that specifically focuses entirely on windows exploit development. Here is an equally amazing series that is probably best used as a supplement during and after that course

If you find that you're struggling with understanding the material (specifically for the OpenSecurityTraining videos), it might be best to follow along the prerequisite knowledge "chain", on the pages for each class (Ex: Confused by exploitation concepts that he doesn't explain in depth in Exploits 2 --> Try out Exploits 1 -- as he probably expects you to know a few things from it already. However, if you find that you may be rusty in assembly --> Sharpen up through their Intro to x86 course, and reviewing/learning C on the side. If you want to understand key differences between Windows and Linux binaries, their Life of Binaries course is pretty good too, but that course itself is not fully necessary for just getting started imo.

If it's a matter of you not being a fan of the teaching style for any reason, an alternative course is Sams Class (which I should let you know ahead of time, covers both linux and windows). Both courses include labs for you to work with as you learn (Sam's class even offering extra mile labs).

As for digging into WinAPI, Windows Internals is probably best used as a reference for when you need it (whether you come across something that specifically requires that information, or reach the point where you need new rabbit holes to dive into). If you can manage to get a course with any of the authors of the book, that may be best for thorough learning of that content. Here is a free alternative, by the co-founder of 'Trail of Bits'.
I personally learned a lot through Windows System Programming and Windows via C-C++, but nothing in this paragraph is necessary to initially jump into windows exploitation. If anything they may be helpful after you start to move beyond the basics.

I'd say CLRS is the most fundamental, since all CS is built on algorithms.

For architecture/systems people (my area):

Computer Architecture: A Quantitative Approach by Patterson and Hennessy. Their other book Computer Organization and Design is excellent as well (and should be read first).

All books by Andrew Tanenbaum. His distributed systems, OS, and network books are excellent reads.

The Dinosaur book for OSes.

I also really like Smith/Nair for Virtual Machines. It is a new book and is not among the classics yet, but it is great.

For memory, caches, and disks, I recommend Jacob. It is also a newer book, but is essential to understand the Von Neumann bottleneck and possible solutions.

And, of course, the dragon book for getting started compilers. Then Ken Kennedy for advanced compilers.


And as a side note:

For AI, Russell and Norvig is required reading.

For type systems, Pierce is awesome.

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

Just learning a couple of languages won't do if your only concern is learning how to exploit. Learning how operating systems work is equally important if not more, though learning a programming language is an obvious first step.

• Start with C then C++ and finally Objective-C. If learning C seems boring/hard take a look at Python first as you'll need it anyway for scripting.
  
  
• Then you'll have to learn ARM/ARM64 to reverse engineer stuff.
  
  Now, I don't know if these are absolutely necessary but they are helpful anyway.
  
  
• Learn and use Linux/BSD the hard way™, using OS X or Windows won't get you too far IMO (I'd actually include easy distros like Ubuntu into that category). Though OS X is almost a necessity to know how iOS works and interact with it, also important since the two have so much in common.
  
  
• You can buy a book to get a general knowledge about binary exploitation, for that you can use this. It's outdated now so I don't know the current state of affairs, you can substitute it for a more modern book.
  
  
• You'll have to get an iOS specific book. Though again it's outdated.
  
  
• Take a look at these tools. Libimobiledevice is awesome
  
  
• After all that you can use some Wargames/CTFs for practicing your skills, e.g http://overthewire.org, http://wechall.net, http://io.smashthestack.org, https://exploit-exercises.com. Though you can ignore this step I guess
  
  
• Start from old iOS, iOS 4 or 5 seem sweet spot.
  
  Also check out http://winocm.moe/research/2013/09/20/resources-for-getting-started/, I might have repeated what she said.
  https://www.theiphonewiki.com/wiki/Up_to_Speed is also useful. However The iPhone Wiki again, is outdated.

Linux or *nix programming in general basically means C programming using system calls. If you are interested in this kind of stuff one of the best books I've ever read on the subject was the Advanced UNIX Programming by Marc Rochkind. Obviously, you have to have a fairly strong C background in order to read this book, but if you want to get into Linux programming this is one of the best books out there in my opinion.

Shell scripting is fine to know (and probably you should) but that doesn't count as Linux programming, the shell is just a tool targeted to the user aka sysadmin to help them manage their system more effectively.

Honestly, first I'd learn C programming if you don't know it. Then learn assembly programming.

From C, you'll understand very basic data structures and common control structures. Even if you know Ruby/Python but not C, I'd still learn it to see what's available at a low level (readily available). It easily translates to ASM as well.

Then see what those turn into. gcc -S -O0. Compile with -S to see the assembly, and -O0 for zero optimization. Optimization turns your program into godknowswhat. You won't recognize your code in it. Everything -O2 and beyond is voodoo.

Pick up a good book on assembly along the way. I recommend "Introduction to 64 Bit Intel Assembly Language Programming for Linux". It's a very easy read. Use that, and try writing a program in pure assembly! Choose a windows or Mac variant if you don't want to do Linux, but that is my focus. They'll all have a slightly different interface (syscalls, ABI).

Also, start learning about the different binary formats. Mach-O for apple, PE for windows, ELF for linux (and BSD I think). You'll probably want to learn C first.

But going back to the article... that's all ARM. I recommend learning x86/64 bit assembly first, but to each their own. ARM is different in a lot of ways, especially with Thumb/Thumb2/ARM mode and all that craziness. Makes RE a lot more difficult IMO. If you're going to do mobile, Android/iOS, you'll need to know ARM, or at least be able to wing it from knowing x86 or amd64 instruction sets.

When you know C, ASM, and binary formats, you'll be well on your way to understand how to patch a binary and what things you need to consider along the way.

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've been a web developer for two years and can tell you what I learned over time that led to me getting an internship at a software company. I didn't major in computer science but I did eventually go to a bootcamp.

I'll note that I'm not a huge fan of that flowchart, because it's backwards. You need to be familiar with what all those tools can accomplish, but I don't think anybody is capable of holding expert-level competence in so many areas at the same time. The key is getting to the point where you know or can figure out what tool will be required for any given task. For example, I don't really know much about Websockets, but I know that I'd probably need them if I wanted to build a chat application.

Anyway, here's my learning track in terms of programming

Pre-2011: Excel formulas

First programming I ever did for a bunch of random things, and at this time I didn't realize I wanted to be in software development yet.

2011-2013: SQL

Started with the DBA where I was working sending me a Word document with some common queries I could run in a SQL client so I could answer other people's questions and same him time. Over time I learned how to change the queries and then write my own. This book helped: https://www.amazon.com/SQL-Queries-Mere-Mortals-Hands/dp/0321444434/ref=sr_1_2?ie=UTF8&qid=1494701750&sr=8-2&keywords=sql+queries+for+mere+mortals

2013-2014: Java, shell scripting, other unix/linux related things

Took a programming class using Java and a shell scripting class in a local university's online program. Used these books:

https://www.amazon.com/Java-Introduction-Problem-Solving-Programming/dp/0132162709/ref=sr_1_14?ie=UTF8&qid=1494701761&sr=8-14&keywords=introduction+to+programming+with+java
https://www.amazon.com/Unix-Shell-Programming-Stephen-Kochan/dp/0672324903/ref=sr_1_6?ie=UTF8&qid=1494701778&sr=8-6&keywords=unix+programming

I think Java is a very good first object oriented language to learn, even though most bootcamps want to do either Ruby or Javascript. Ruby (and Rails) have a little too much syntax sugar and other shortcuts that make it hard for a beginner to understand, and JavaScript is just plain weird (along with its ecosystem, which requires knowing a little history of the language and why it is the way it is).

2015: Ruby, Rails, a little JS. Attended a bootcamp and got my first job.

2016: ReactJS, actually understanding JS

2017: More JS, and now learning Elixir and the Phoenix framework.



As I mentioned before, these languages and frameworks are just tools. The way I've learned has been to do projects, figure out what tools would be necessary to accomplish all the functionality, and then slowly make progress on learning how to use those tools, eg, copy/pasting, modifying code other people have written, and then finally taking the training wheels off.

I always liked Sobells book "A Practical Guide to Linux Commands, Editors, and Shell Programming"

https://www.amazon.com/Practical-Guide-Commands-Editors-Programming/dp/0134774604/ref=dp_ob_title_bk

For programmers, "The Linux Programming Interface" is excellent.

http://man7.org/tlpi/

but read "The C programming language" first, and possibly "Modern C" as well.

"The little book about OS development" is great if you want a technical book about the inner workings of a OS

https://littleosbook.github.io/

In general, older books can be good, especially if they are about the lower level stuff that is common for all distributions, like GNU tools, programming aspects and OS theory / POSIX.

For Debian, "The Debian Administrator's Handbook" is good

https://debian-handbook.info/

For Arch, the Arch wiki is invaluable

https://wiki.archlinux.org/

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.

If I had known about the existence of these two books (or rather, their earlier editions) a decade ago, I would have been well on my way to being a better Windows programmer. These two are MUST READS for win32 programming (if you don't want to use .NET framework or other abstraction layers.)

Windows Internals, by Russinovich and Solomon

Windows via C/C++, by Richter and Nasarre

Again, if you want to do non-.NET Windows programming, these books are pure gold. (The older books by Charles Petzold are kind of getting out of date, but were good too.) Also, check out Raymond Chen's blog The Old New Thing for tons of cool bits of Windows dev history

EDIT: Also a must read: Advanced Windows Debugging this is a must if you want to learn how to properly debug "unmanaged" (i.e. non-.NET) applications. Also a pretty good intro to reverse engineering or cracking apps on Windows.

Even if you aren't going to use C++ I would suggest getting Windows Via C++ by MS press (http://www.amazon.com/Windows-via-Pro-Jeffrey-Richter/dp/0735624240). It is by far the best way to learn the internals on how windows works and helps a lot with those head scratching moments even with higher level languages. COM is also used a LOT in widows programming. Being able to understand how it works can be a big help as well.. There is the "Don Box Book", Essential COM which I'd buy. You'll probably only need the first couple of chapters but It is a really well written book as to not only what COM is but WHY it is and how it came to be.

Also for C++. If you have VS Express installed get the Windows SDK (it's free) and look up how to integrate it with VS. It is a LOT more powerful and you get a lot of useful tools with it as well as decent samples.

While you did mention you prefer hard copies, if you want him to stay current, you should consider a subscription at safaribooksonline.com as it has just about every O'Reilly book there is and you/he can always order a hard copy if desired. Otherwise High Performance MySQL 3rd Edition is pretty great, especially with explaining replication and backup/restoration procedures, as well as DevOps Troubleshooting, which has a great section on troubleshooting the boot-up process that may be useful.

;Default font:

(set-frame-font "Monaco Regular 18")

;Set the background to black:

(set-background-color "black")

You can copy those lines to your scratch buffer ,"C-x b *scratch*", place the cursor at the end of the line and hit "C-x C-e" and they should take immediate effect.

Steve Yegge did a nice post about emacs configuration that is a pretty good intro into how to organize all of your modes.

If you want to harness the true power of emacs, you will have to learn a little lisp. If you've never seen lisp before, I would recommend starting with John McCarthy's original introductory paper. The place to go from there would be
Glickstein's Writing GNU Emacs Extensions. Though some of the particular configuration information is a bit dated, it is a perfect introduction to programming in emacs lisp (elisp). Last but not least, there is the Programming in Emacs Lisp online resource at gnu.org. Hope that helps!

The approach I took is to start with commands and languages using regular expressions: find, grep, sed, awk, python or perl, etc. These are very powerful and useful commands.

Two books I highly recommend are [Unix Shells by Example] (http://www.amazon.com/UNIX-Shells-Example-4th-Edition/dp/013147572X/ref=sr_1_1?ie=UTF8&qid=1374157897&sr=8-1&keywords=unix+shells) and [A Practical Guide to Linux] (http://www.amazon.com/Practical-Guide-Commands-Editors-Programming/dp/013308504X/ref=sr_1_1?s=books&ie=UTF8&qid=1374157979&sr=1-1&keywords=practical+guide+to+linux)

Also check out (PDF warning!) [Advanced Bash Guide] (www.tldp.org/LDP/abs/abs-guide.pdf)

These all are excellent, and very useful.

You might be interested in reading Practical C Programming. This book is about C (obviously) but it has really helped me understand what good code is supposed to look like. It looks very much like yours! I recommended it to all.

Not as far as I know, but I've seen this book being recommended some times: http://www.amazon.com/Programming-POSIX-Threads-David-Butenhof/dp/0201633922/

I've never read it.

APUE is generally recommended (not specifically for multithreading though), and it has chapters on multithreading and multiprocess programming: http://www.amazon.com/Advanced-Programming-UNIX-Environment-Edition/dp/0321637739/

Obs.: People are talking about multithreading a lot, but there are other approaches. Multiprocess is another way to possibly take advantage of multiple cores on a CPU or multiple processors on a computer. Differences between the two approaches involve:

• what your OS defines as a thread and as a process (processes and threads are commonly OS supported concepts, but I've read about multithreading that doesn't require specific OS support for threads [green threads - check http://c2.com/cgi/wiki?GreenVsNativeThreads], but I've never heard multiprocess programming without the assumption of the existence of an OS that supports the idea of a process and of multi processes running "at the same time" [it seems possible to me to extend the notion of green threads and come up with something like green processes, but I've never seen that done out there]);
  
• what means through which threads can pass data around and what means through which processes can pass data around;
  
• the amount of resources it gets utilized to create and destroy a thread and a process;
  
• etc.
  
  Processes are generally heavier weight (they spend more resources) and are more isolated from each other, in comparison to threads.

> can someone give me a few suggestions of things to read up on in terms of linux shop debug workflow?

This book shows why some programmers love emacs so much:

http://www.amazon.com/Writing-GNU-Emacs-Extensions-Customizations-ebook/dp/B0043M56SW/ref=sr_1_2?ie=UTF8&qid=1427123072&sr=8-2&keywords=emacs+lisp

The info pages for gdb are good and there's plenty of websites giving short tutorials on how to debug with it.

This book is good for make:
http://www.amazon.com/Managing-Projects-Make-Nutshell-Handbooks/dp/0596006101/ref=sr_1_1?ie=UTF8&qid=1427123212&sr=8-1&keywords=make+oreilly

The Linux Documentation Project is a great free resource:
http://tldp.org/LDP/Bash-Beginners-Guide/html/

A Practical Guide to Linux Commands, Editors, and Shell Programming (4th Edition)
https://www.amazon.com/dp/0134774604/ref=cm_sw_r_cp_apa_bh7QAb518JBC8

The first two are for learning Bash; this is an awesome resource for learning how to administer RHEL/CentOS7:

RHCSA/RHCE Red Hat Linux Certification Study Guide, Seventh Edition (Exams EX200 & EX300)

https://www.amazon.com/dp/0071841962/ref=cm_sw_r_cp_apa_wj7QAbX8M0DG5

Read "The Linux Command Line" from cover to cover (it's free). You'll easily be a beginner shell scripter by then and probably a better Linux user overall. The book is also an easy read.

From there go into "Unix Shell Programming". If you reduce the gap between the 2 books, the 2nd book will also be an easy (yet somewhat dry) read.

Try to build some small projects while going thru the material. If you use it you'll be more apt to retain the info.

That's what I did. Took me 2 months of reading afterhours of my full time job. By the time the 2 months was up I surprisingly knew more shell scripting than most Linux Admins I've met since. (Admittedly, a lot of people in IT really don't know as much as they try to make it seem.) The only thing missing was experience and projects to use as practice.

Edit: You probably would do really well getting a LinuxAcademy subscription for a year and go thru as much as possible.

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'm neither an expert on OS or have any books to compare my experience with, but https://www.amazon.com/Operating-System-Design-Approach-Second/dp/1498712436 which uses the xinu operating system was a great and useful experience.

Mostly when he talks about the process/thread implementation and the process memory working set and page replacement algorithms. Also when he talks about the Unix security model (user|group|all). It is now a bit more elaborated than that, and you can use ACLs almost like in Windows. And at one point he asks when was the last time someone used pipes (|) for composing programs!

I would recommend this book, UNIX Internals: The New Frontiers, that explains the internal implementation of a variety of Unix systems in the mid nineties. Amazon says that a new edition is planned for January next year, good news!

C targets a virtual memory system and instruction set architecture (ISA). It's an abstraction over the hardware implementation of the ISA. Those worlds are just different, and you'll gain a better understanding if you just study them separately.

for computer architecture, I've found two books to be most helpful.

https://www.amazon.com/Digital-Design-Computer-Architecture-Harris-ebook/dp/B00HEHG7W2

https://www.amazon.com/Structured-Computer-Organization-Andrew-Tanenbaum/dp/0132916525/ref=sr_1_1?ie=UTF8&qid=1536687062&sr=8-1&keywords=tanenbaum+computer+architecture&dpID=41B7uYANs%252BL&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch

there is a low level operating system book that uses a lot of C code to explain how to build a kernel. This might interest you

https://www.amazon.com/Operating-System-Design-Approach-Second/dp/1498712436

>There are a number of patterns for compile-time polymorphism, tagged dispatch, and selective compiling. There are expression templates that you can composite your functions and the compiler can generate optimized code {...}

Can you link to some blogs/books you think are particularly insightful?

>Compile times don't matter. I would abhor delivering an inferior product because I was incensed by a compile time.

For what it's worth, we also use distributed compiling using IncrediBuild -- our build system is complex enough to have a dedicated engineer working on it, and I would not pretend to totally understand how it works.

I will say that despite the minimal use of templates, pushing all configuration to scripting to minimize our C++ footprint, and our (hopefully not needlessly) sophisticated build system, a total build/compilation of all of our software would still take hours.

It could be that some of our developers aren't outstanding. It could also be that we have some legacy code that needs to be rewritten. But whatever the reason is, it's very easy to say "hey, I want to write the best possible software, development time be damned", but there is a finite amount of time our developers can spend working, and it would be a shame to spend a large amount of those hours waiting for things to compile.

I used to agree with you. I could never understand why compilation times matter as long as the software works. Then I started working as a professional developer, with requirements and deadlines.

Please realize that this isn't an attempt to lecture you. You definitely have a lot more experience than I do, and I want to hear your thoughts. Some of what you said just doesn't seem to line up with my experience is all.

And this doesn't even get into the issues with debugging -- maybe your (seemingly) extensive experience working with templates has given you the means to decipher those cryptic error messages, but I usually can't make heads or tails of them, which is why I asked you for some recommended resources. It's somewhat unfortunate that I won't get the experience through my job directly, which is rooted in what led me to this anti-template bias in the first place.

>cached builds

I would also like to read more about this, if anything comes to mind. As I mentioned, I'm not super familiar with the build process; I have a linker textbook on my shelf that I intend to get to soon, but I don't think that will help with what you refer to here.

Yes, the C standard library will be linked to your program by default. You can change this by compiling with the -nostdlib option (assuming you're using gcc); then the C standard library won't be linked in.

You might find this interesting:
https://blogs.oracle.com/ksplice/entry/hello_from_a_libc_free

The C standard library is usually linked as a "shared library", meaning that it's not actually entirely inserted into your executable, but rather a .so or .dll file is loaded at runtime.

On Linux I can use the ldd command to see what shared libraries are loaded by a given program. For example:

$ ldd ./a.out
linux-gate.so.1 => (0xb779c000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xb75d4000)
/lib/ld-linux.so.2 (0xb779d000)

The third line shows that this program (a.out) uses the C standard library (libc), which, in compiled form, is found in /lib/i386-linux-gnu/libc.so.6.

A nice book about this stuff is Linkers and Loaders by John Levine.

haven't read that one, but this one is pretty good too.

I haven't read the book but after attending his talk not surprised to hear this at all ;-)

I still find David Butenhof's Programming with POSIX Threads the best introduction to thread-based concurrency even through there is zero C++ (modern or otherwise). But once you understand the fundamentals (like why you need to hold the mutex when calling wait() on condvar), then all the APIs (like that of C++11) become fairly transparent.

Here are a couple books I have. The author of the first one was a teacher of mine a while back. She really knows her stuff. That book in particular is good for explaining all the protocols involved and how the packets are put together.

http://www.amazon.com/TCP-Illustrated-Protocols-Addison-Wesley-Professional/dp/0321336313/ref=sr_1_1?s=books&ie=UTF8&qid=1382132562&sr=1-1&keywords=tcp+ip+illustrated


This second book is more general networking stuff. Still some really good reference material.

http://www.amazon.com/Illustrated-Network-Modern-Kaufmann-Networking/dp/0123745411/ref=sr_1_7?s=books&ie=UTF8&qid=1382132562&sr=1-7&keywords=tcp+ip+illustrated

And for operating system basics, this is a good all-rounder:

http://www.amazon.com/Operating-Concepts-Seventh-Abraham-Silberschatz/dp/0471694665/ref=sr_1_4?s=books&ie=UTF8&qid=1382132818&sr=1-4&keywords=operating+system+concepts

And for *nix because it is important and nobody thinks about it:

http://www.amazon.com/UNIX-Linux-System-Administration-Handbook/dp/0131480057/ref=sr_1_1?s=books&ie=UTF8&qid=1382132917&sr=1-1&keywords=Linux+System+administration

http://www.amazon.com/UNIX-Internals-The-New-Frontiers/dp/0131019082

I'm surprised this one hasn't been mentioned yet; it's arguably one of the best book on UNIX operating systems design. It gives a lot of valuable information on how to efficiently implement SMP kernels which is something missing from a lot of other books. Maybe not adequate if you're a complete beginner though.

I personally have no experience, but I've heard good things about iOS hackers handbook. It's most likely not current but it might be a good start.

You can install spacemacs and other custom configs as a way of discovering what's out there and how to do things, and then put the things you like and understand in your own init.el.

This is a good book to get started: Writing GNU Emacs Extensions: Editor Customizations and Creations with Lisp.

Just go slow, try out lots of configs for ideas, build up your customizations over time.

I picked up Professional Android 2 Application Development a while ago and worked through some of the examples in there.

But honestly? I used the Android docs from Google and some of their examples as well as some strategic Google searches for when I'd get stuck. The book is nice to have when I want to spend some time away from the computer but online resources are better (even if you have to hunt around a bit).

My current external dependencies are Jsoup for HTML parsing and tesseract-ocr for image recognition.

Edit: Just realized you meant the Eve api. This isn't using it atm.

The closest thing I can think of is Uresh Vahalia's book "UNIX Internals". It's more technical than Code, but it's really quite well written and clear. It's somewhat hard to find, though.

http://www.amazon.com/UNIX-Internals-The-New-Frontiers/dp/0131019082

If you're serious about this, and want to do it right, I'd recommend locating a copy of Writing GNU Emacs Extensions by Bob Glickstein.

While it is a little out of date with respect to recent versions of emacs (some things are easier now, and a few "best practices" have changed), it is still an excellent overview of writing emacs extensions.

I'd be a little cautious about following it's tutorials due to the previously mentioned changes (you will still need to do some additional manual reading), but as far as a starting point and overview of what is involved, I can't think of a better resource.

If you're programming for POSIX environments, this book is an absolute reference. It's as old as pthreads, but still relevant, especially the explanation of various multi-threading paradigms, such as pipeline and worker group. Plus it's much better than OReilly's book on pthreads.
If you're developing for multiple platforms and want to stay 100% C++ /u/Meowiavelli 's recommendation is def. top notch.

I learned it from the dinosaur book:

http://amzn.com/1118063333

If you are resourceful you can find this book for free. Or you can get older versions for very cheap (http://amzn.com/0471694665) and the relevant concepts are still pretty much the same.

https://www.amazon.co.uk/Linkers-Kaufmann-Software-Engineering-Programming/dp/1558604960?SubscriptionId=AKIAILSHYYTFIVPWUY6Q&tag=duckduckgo-iphone-uk-21&linkCode=xm2&camp=2025&creative=165953&creativeASIN=1558604960

good book about the final stages and how the OS actually starts the program up if you want to know more. easy read too for a nerdy topic!

I would definitely take a look at The iOS Hacker's Handbook. It's an excellent resource for understanding the fundamentals of jailbreaking.

I recently got into https://www.hackerrank.com/ and it's amazing! There's a Bash section there. It's not gonna teach you Bash, but it will help you with exercises.

For learning Bash: http://www.amazon.com/Shell-Scripting-Expert-Recipes-Linux/dp/1118024486/

I enjoy reading shell scripts. This was an interesting premise for a blog but a bit light.

I'd recommend:

http://www.tldp.org/LDP/abs/html/

http://www.amazon.com/Unix-Shell-Programming-Stephen-Kochan/dp/0672324903/ref=sr_1_16?s=books&ie=UTF8&qid=1376482562&sr=1-16&keywords=shell+script+programming

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.

If you're looking for a book I highly recommend Unix Shells by Example:

http://www.amazon.com/UNIX-Shells-Example-4th-Edition/dp/013147572X/ref=la_B001H9RV1E_1_2?ie=UTF8&qid=1346897356&sr=1-2

I like it because it's light on the banter and explanation that's so common with tech books, and heavy on the examples. It's had a permanent spot on my work bookshelf for the last 10 years

The best part is it's from the first (or second) chapter of this textbook which is very, very widely used.

After taking a quick look at some of the comments/responses, I would suggest taking a look through some introductory C material. I would recommend Practical C by O’Reilly, or a Udemy course. Either could help with the understanding of function declarations, data types, and arrays.

You should give O'Reilly's Practical C a try. Great introduction to C.

UNIX Shells by Example by Ellie Quigley is a great text to pick up shell scripting.

If your brother already knows how to program then I would recommend Professional Android 2 Application Development. I like it because it is concise and lets you look up how to do something quickly.

I should mention I never went to lecture and learned everything from "operating systems concepts" 7th edition http://www.amazon.com/gp/aw/d/0471694665/ref=pd_aw_sbs_3?pi=SL500_SY115 and I loved it.

For cash-in-pocket noobs who like to have a book in hand I'd recommend any of these books by Mark G. Sobell.

A Practical Guide to Linux
Old (1997) but takes you from the basics to intermediate.

A Practical Guide to Linux Commands, Editors, and Shell Programming, 4th. Ed.
Also covers the basics but it's more focused on those subjects included in the title.

A Practical Guide to Ubuntu Linux, 4th. Ed
I have no experience with this book but I'm including it for completeness.

A Practical Guide to Fedora and Red Hat Enterprise Linux, 7th. Ed.
Same. No experience.

http://www.amazon.com/Professional-Android-Application-Development-Programmer/dp/0470565527

That book helped me more than anything when I first started out. FYI this book assumes you know Java at least alright.

I'm partial to my copy of Operating System Concepts, which features a nice watercolor painting of dinosaurs on the front cover. (Every edition has a dinosaur theme. I'm not sure why. And no, there are no references to dinosaurs in the text.) For a textbook, the cover is beautiful.

I found this to be a useful starter.
https://www.amazon.com/dp/0201633922

Maybe this book would be of some help? I just ordered this for myself and from what I've heard about it, it's a very good book to learn about how iOS works & how to defeat it.

[Book](iOS Hacker's Handbook https://www.amazon.com/dp/1118204123/ref=cm_sw_r_cp_api_C0VCybEAQFC95)

Just because textbooks and reference books can be dry doesn't mean they're not creative.

Here's another and another. O'Reilly published books have a couple clever or "funny" ones.

Buy this book: <https://www.amazon.com/Unix-Shell-Programming-Stephen-Kochan/dp/0672324903> and learn how the POSIX shell can make your life easier.

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.

> For the STEM fields though, I think it is necessary to have very up to date textbooks

Nope not even those. Any 100-400 level course ... same shit different decade. 500- PHD, whelp, you be looking at Elsevier or recently published journals.

Example: Linkers and loaders this book gets into how Java does it's thing. The course I did was on VAX and OS390 which is not too relevant now but that was 20 years ago.

Even the Patterson / Hennessy book on architecture the older volumes are a good introduction. If you are going to work in Intel, they'll have a training course to bring you up to speed on the current technology that they're doing.

I'd recommend watching Writing Games in Emacs for a simple tic-tac-toe mode and then reading Writing GNU Emacs Extensions which culminates in a crossword mode.

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

Sure, Programming with POSIX threads and Unix Network Programming, Volume 1.

The source in the littleosbook builds on itself each chapter. However, it's important to know that the littleosbook, osdev wiki and most online resources aren't necessarily "tutorials" after the bootloader and bare-bones stages. Any later information is going to be more abstract and guidance. If you need in depth assistance with osdev, you'll want to invest in one (or more) of the following:

• Operating Systems Concepts
  
• Design and Implementation of FreeBSD
  
• Linux Kernel Development
  
• Any of the open courseware courses on operating systems provided by MIT, Stanford or UMass on YouTube.
  
  And a lot of your personal time.

Either works. If your trying to land a job working with Linux, read " The Linux Command Line" if you want to understand Linux try "how Linux works"

Also check out "Devops troubleshooting" - https://www.amazon.com/dp/0321832043/ref=cm_sw_r_cp_apa_lhVJzbGBZ02RN

Check out "LPI in a nutshell" - https://www.amazon.com/dp/0596005288/ref=cm_sw_r_cp_apa_NiVJzbQ3C4ZZ1

Back when I was developing low level applications on Windows, I purchased: https://www.amazon.com/Programming-Applications-Microsoft-Windows-General/dp/1572319968 (newer version: https://www.amazon.com/Windows-via-Jeffrey-M-Richter/dp/0735624240/ref=dp_ob_image_bk)

It is a very well written book. When I wanted to learn more, the author (Jeffery Richter) pointed me to:
Windows Internals by Mark Russinovich (https://docs.microsoft.com/en-us/sysinternals/learn/windows-internals).

Between the 2 (now 3 since Windows Internals has part 1 & 2), you should get a solid foothold programming in Windows.

There is a book devops troubleshooting that has alot of the scenarios you are asking for. Link

Some of the well known jail breakers are writing a book on that right now, but it isn't finished.

http://www.amazon.com/iOS-Hackers-Handbook-Charlie-Miller/dp/1118204123

I realize this has more than the OP was looking for (ie the other shells). but UNIX Shells By Example is by far my favourite book I've come across in terms of learning scripting, might want to check it out.

1. Learn linux - https://www.amazon.com/Practical-Guide-Commands-Editors-Programming/dp/0134774604/ref=sr_1_3?s=books&ie=UTF8&qid=1540917384&sr=1-3&keywords=A+Practical+Guide+to+Linux+Commands&dpID=51mIubCikPL&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch
   
   
2. Learn your distro - IE find a good book on debian, ubuntu, fedora, or the arch wiki
   
   
3. Interact with their forums
   
   
4. Remember that no one knows everything; but most people will expect that you at least do a google search to find more information about your poblem.

If you're talking about Windows, Windows Via C/C++ is what you want.

Buy a used copy of this:

http://www.amazon.com/Practical-Programming-3rd-Steve-Oualline/dp/1565923065

Unix Shell Programming (3rd Edition), by Stephen Kochan (old bell labs employee):

http://www.amazon.com/Unix-Shell-Programming-3rd-Edition/dp/0672324903

A Practical Guide to Linux Commands, Editors, and Shell Programming (4th Edition) by Mark Sobell.

Operating System Concepts

Read iOS Hackers Handbook http://www.amazon.com/dp/1118204123), and this http://www.idownloadblog.com/2011/09/13/i0n1c-exploit-report/).

UNIX Shells by Example by Ellie Quigley. Reviews here.

This might be a good starting point, but I have no idea how outdated the information is. There's another book that was released last year but I can't remember the name of it.

Edit: Found it

/u/modalbony

No, that's operating systems.

This was my book for a 400-level class. I still own it, but it looks ridiculous.

Sure beats the hell out of DINOSAURS?!

>What exactly do you mean by watching it to see CPU? I'm quite familiar with Top -u, but is there a way to view just that processes CPU? I kind of want to watch it through my computer while browsing and see what happens.

You need to get its PID first. My favorite way to do that is with System Status from the App Store, which lists running processes with PIDs (although you can't kill them or anything).

Then use:

top -pid PID

To see just that process's stats.

>Does that Jetslammed tweak have anything related to this or help this?

Jetslammed can change a launchdaemon's HighWaterMark RAM limit, the limit of sustained RAM usage at which Jetsam automatically kills the daemon.

http://newosxbook.com/articles/MemoryPressure.html

The HWM can also be changed manually, but, in the end, it doesn't really help that much unless a daemon is only dying due to exceeding its HWM.

It can still be killed for other reasons if the system is low on memory.

It doesn't actually keep discoveryd from EVER being killed, so it doesn't really solve the issue of very large hosts (>300 KB) files causing random website disconnects due to discoveryd dying, leading to DNS failure.

It really just fixes it so that you can have Wifried and a small ad blocking hosts file at the same time since Wifried + even a small hosts file (like Light UHB) will cause discoveryd to use about 9-10 MB, exceeding the 8 MB HWM limit for a long period of time, causing discoveryd to be automatically killed, causing Wifried to re-initialize Wifi, causing random Wifi disconnects, which is even more problematic than even a DNS failure.

Wifried with Jetslammed raises the HWM for discoveryd to 12 MB from 8 MB, preventing the HWM killing of discoveryd with Wifried + small ad blocking hosts file. A large hosts file will exceed even this new limit, but, in that case, where discoveryd uses 20 MB or more, it will be killed by the system anyway for other reasons not related to the HWM.

>So do I have the correct Light UHB? Is that the one you use? I guess I might try reinstalling and maybe see. Haven't had an issue since its crash and (haven't checked today) haven't seen it anywhere near the top when running "top".

I use Light Untrusted Hosts. I've watched discovery's PID for about a month now. It's not being jetsam killed anymore even if I load a LOT of tabs and really stress it out. It never goes over 8 MB (the HWM) for any sustained period of time (even 8 MB requires A LOT of DNS activity), and never reaches enough RAM usage that the system would think to kill it to free memory (10-20 MB). Gamed (the GameCenter daemon) uses more memory than discoveryd with Light UHB . . .

>-unrelated- I love learning about all this stuff and your fountain of knowledge so far. Mind if I asked where you learned so much? I've been learning a lot about daemons lately, especially locationd and backboardd. I'm just curious as to where I can learn more about this stuff, learn how to read crash logs as so far it's just from the little experience I have, etc. I just can't find any good resources..

I've used OS X since it was in beta, and iOS is secretly just OS X in disguise with a TouchUI, a few processes missing, and a few processes added.

This book has been helpful to me in understanding jailbreaking, although it is a bit dated:

http://www.amazon.com/iOS-Hackers-Handbook-Charlie-Miller/dp/1118204123

Also a bit dated, but you may like it if you have a Mac:

http://www.amazon.com/Learning-Unix-OS-Going-Terminal/dp/1449332315/ref=sr_1_1?s=books&ie=UTF8&qid=1418694791&sr=1-1&keywords=OS+X+unix

This wiki is also good. Many devs post on it:

https://theiphonewiki.com/wiki/Main_Page