The exact four books I read are:

Learning Obj-C

Learning Java

iOS Programming: The Big Nerd Ranch Guide

Android Programming: The Big Nerd Ranch Guide

However, I would now recommend learning Swift instead of Obj-C. At the time when I was looking into iOS books, good books on Swift were few and far between.

Here below is my copy pasta of C#/Unity stuff which I post pretty often here.

Free C# ebook

• http://www.csharpcourse.com/ <- The download link is under 'here' at the end of the first paragraph.

If you want youtube tutorials:

• https://www.youtube.com/playlist?list=PLGLfVvz_LVvRX6xK1oi0reKci6ignjdSa <- apart from C# this dude has also A LOT OF other tutorials on many other languages.

• https://www.youtube.com/watch?v=pSiIHe2uZ2w <- has also pretty good Unity tutorials.

• https://scottlilly.com/build-a-cwpf-rpg/ <- learn WPF (desktop application with GUI) by making simple RPG game.

Book reference guide:

• https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650/ref=sr_1_1?ie=UTF8&qid=1547990420&sr=8-1&keywords=C%23+in+a+nutshell <- But treat is as a language reference guide, not a programming learning guide.

Text-based tutorials

• https://www.tutorialspoint.com/csharp/index.htm <- C#

• https://www.tutorialspoint.com//wpf/index.htm <- WPF (GUI programming)

Udemy - wait for $10 sale which occurs at least once in a month:

• https://www.udemy.com/csharp-tutorial-for-beginners/ <- for C#, dude has also more advanced tutorials to choose from.

• https://www.udemy.com/user/bentristem/ <- for Unity

Do not move to Unity or WPF before you get good grasp on C# syntax and OOP concepts.

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

Going through the Stanford List, here are the books listed there that I have also used and thought positively of:

• Algorithms: Introduction to Algorithms
  
• Computer Networks: Computer Networking (Nice name)
  
• Machine Learning: Artificial Intelligence: A Modern Approach
  
• Programming: C Programming Language
  
  Of the list, the only one I have read and didn't like was Operating System
  Concepts. It's not that it was terrible, per se, I just liked Modern Operating Systems a lot more. I used the third edition, but I can't imagine the 4th is any worse.

First of all you don't need to write a billion lines of code to create an OS. The first version of Minix was 6000 lines long. The creator of Minix, Andrew Tanenbaum, has a great book called Modern Operating Systems, in which he explains the inner workings of several famous operating systems.

Considering the emphasis on "from scratch", you should also have a very good understanding of the underlying hardware. A pretty good starter book for that is Computer Organization and Design by David A. Patterson and John L. Hennessy. I suggest reading this one first.

​

I hope this can get you started.

C# in Depth - Jon Skeet

C# 7.0 https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

Computer Science:

• Structure and Interpretation of Computer Programs
  
• Introduction to Algorithms
  
• Operating System Concepts
  
• Theory of Computation
  
• Any intro linear algebra textbook
  

"Introduction to Algorithms"by Cormen et.al. Is for me the most important one.

The "Dragon" book is maybe antoher one I would recommend, although it is a little bit more practical (it's about language and compiler design basically). It will also force you to do some coding, which is good.


Concrete Mathematics by Knuth and Graham (you should know these names) is good for mathematical basics.


Modern Operating Systems by Tennenbaum is a little dated, but I guess anyone should still read it.


SICP(although married to a language) teaches very very good fundamentals.


Be aware that the stuff in the books above is independent of the language you choose (or the book chooses) to outline the material.

Just learn Objective-C. You'll find much more material and examples and it'll be another language you have under your tool belt. It's also the de facto standard for Cocoa development, even if there are Python bindings.

This book is good: http://www.amazon.com/Programming-Objective-C-2-0-Developers-Library/dp/0321566157/ref=sr_1_1?ie=UTF8&s=books&qid=1250177866&sr=8-1

You must be on x86_64 Linux. Extract the tarball into a directory of your choice. Set the environment variable LD_LIBRARY_PATH to include that directory. Then run randprog in that directory. If you don't understand what I just wrote, go away and learn before coming back. This book will help you https://www.amazon.com/Unix-Programming-Environment-Prentice-Hall-Software/dp/013937681X

I really enjoyed this text in my operating systems course. https://www.amazon.ca/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X

I'm sort of in the same boat as you, except with an aero and physics background rather than EE. My approach has been pretty similar to yours--I found the textbooks used by my alma mater, compared to texts recommended by MIT OCW and some other universities, looked at a few lists of recommended texts, and looked through similar questions on Reddit. I found most areas have multiple good texts, and also spent some time deciding which ones looked more applicable to me. That said, I'm admittedly someone who rather enjoys and learns well from textbooks compared to lectures, and that's not the case for everyone.

Here's what I gathered. If any more knowledgeable CS guys have suggestions/corrections, please let me know.

• Intro-ish: Structure and Interpretation of Computer Programs by Abelson & Sussman
  
• Math: Mathematics for Computer Science by Lehman et al.
  
• Computer Architecture: Computer Systems A Programmer's Perspective by Bryant & O'Hallaron
  
• Algorithms: Introduction to Algorithms by Cormen et al.
  
• Programming Languages: Programming Language Pragmatics by Scott
  
• Computational Theory: Introduction to the Theory of Computation by Sipser
  
• Operating Systems: Modern Operating Systems by Tanenbaum & Bos
  
• Networks: Computer Networks by Tanenbaum
  
• Compilers: Compilers by Aho et al.
  
• Security: Security Engineering by Anderson
  
• Type Theory: Types and Programming Languages by Pierce
  
• AI: Artificial Intelligence: A Modern Approach by Russell & Norvig
  
  Full disclosure: I haven't actually read more than the preface of any of those books. Software engineering topics are more directly applicable to me than CS topics right now, so here are some that I've actually started reading:
  
  
• The Pragmatic Programmer by Hunt & Thomas
  
• Clean Code by Martin
  
• Code Complete by McConnell
  
• Design Patterns by Gamma et al.

For anyone who wants to learn app development, I can't recommend TheBigNerdRanch enough. They have the best books available

https://www.amazon.com/iOS-Programming-Ranch-Guide-Guides/dp/0134682335/ref=sr_1_1?ie=UTF8&qid=1499361104&sr=8-1&keywords=ios+programming

https://www.amazon.com/Swift-Programming-Ranch-Guide-Guides/dp/013461061X/ref=pd_sim_14_1?_encoding=UTF8&pd_rd_i=013461061X&pd_rd_r=EH8QEXAFBS073X065FRB&pd_rd_w=MlTL0&pd_rd_wg=ZECyJ&psc=1&refRID=EH8QEXAFBS073X065FRB

https://www.amazon.com/Android-Programming-Ranch-Guide-Guides/dp/0134706056/ref=pd_sim_14_3?_encoding=UTF8&pd_rd_i=0134706056&pd_rd_r=M9MB62KF7YSYKDGA8DER&pd_rd_w=q9x3K&pd_rd_wg=n4RMO&psc=1&refRID=M9MB62KF7YSYKDGA8DER

Along with those I also frequented a few programming subreddits and watched many youtube videos on iOS and Android.

To be fair, only one of them appears to be reading the UNIX book; the other girl is reading a paperback novel.

Worse yet, it's not even a very good UNIX book. Wake me up when you've got a photo of a hot chick reading Stevens. Gotta have standards.

Coming from a C++ background I find [C# in a Nutshell] (https://www.amazon.ca/dp/1491987650) to be great. Concise, to the point, but nothing is (or seems to be) left out.

If you're new to C, read K&R.

Once you've done that (or if you already know C) then read THE book on Unix programming

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

Thanks ;). Not so skilled on that and my advice might be misleading; though I got a background in cs:This would be my suggestion for someone beginning.

• Understanding how comp works. Books: Code and Element of computing systems -> Video NandToTetris
  
• Programming( web programming(HTML/Javascript/PHP etc),C, bash, Python,(other script lang e.g perl, ruby etc) and assembly. In that order and database(e.g msql)
  
• Networking. book Computer Networking: A Top Down Approach. video Computer Networks by David Wetherall. Also some CCNA books
  
• How Linux works, Windows internals, and Modern Operating Sytems
  
• Cryptography by Christof Paar and cryptopal challenges
  
• Computer System Security
  
• Any other materials related to infosec. look at HowToHack resources on the sidebar. Also opensec
  
• Play some CTF e.g OverTheWire, smashthestack
  You can also search for those books pdf by using google hacks eg filetype:pdf "title of the book here" or intitle:index.of "title of the book here"

Yup, check this out:

[India: 360 Rupees (about 6.59$)](
http://www.flipkart.com/modern-operating-systems-8120339045/p/itmdytdczrzjrwgq?pid=9788120339040&ref=93cc510a-81d9-41c2-a5b9-f4a0a0760070)

US: 126.73$

Quality of paper is not the same though. And no colour diagrams, its all black and white in India. And paperback instead of Hardcover.

Advanced Programming in the UNIX Environment

I feel like C is most useful when you are programming directly to an OS and its resources, rather than through a framework or library. And you don't often need to use the most elegant data structures to accomplish a simple task.

The Linux Programming Interface is still one of the best introductions to Linux programming.

You're asking a very, very very large question here. I'll try and directly answer this but I may go off on some detail. Also these details will be summarized so anyone reading this, you can pick it apart. It isn't meant to be exact.

> What exactly is a packet?

Its just a chunk of data. This chunk of data contains all types of things it will need to get where it is going safely. Source. Destination. Checksums. Settings. And of course the data within. In TCP this chunk of data can be up to 64 kilobytes. However before this chunk of data hits the physical wire, it has to be split up into its Maximum Transmissible Unit. Which is just a fancy way of saying "this is the agreed upon maximum chunk of data size for this network". Typically the MTU is around 1500 bytes. It is also known as a "frame" since an MTU of 9000 is also called "jumbo frames"

Think of an MTU size like the gears in a car. A lower MTU size is like a lower gear. It gets you going faster, since once you have 1500 bytes of data you can fire that packet off, instead of sitting around waiting for 9000 bytes of data to fill up.

The downside to this is that each packet sent requires a series of interrupts. And interrupts can be costly (especially back in the day!). When an interrupt fires, it goes to the kernel and says "HEY! I NEED SOMETHING DONE!". The kernel says "alright little buddy, lets get you what you need." and then the kernel assigns a core to handle the interrupt. When the interrupt is being handled, nothing else on the core gets done. It has a full lock on that core until the job is done or the interrupt itself (depending on the type of interrupt) is interrupted itself. And yes before you ask, certain types of interrupts cannot be interrupted.

So you can imagine back in the day of single core systems, this could really suck. Because if you have a single core servicing interrupts for 1500 MTU sizes instead of 9000 MTU sizes, you're servicing 6* as many interrupts. Which means your processor literally stops what it is doing to handle the interrupt, and then once done goes back to what it was doing. I could go into kernel preemption and interrupting interrupts but I won't. Too long.

These days interrupts aren't so bad as we have many many cores to service them. If you've ever run into the irqbalance service, it is responsible for basically round-robining interrupts across all cores (cat /proc/interrupts to see).

> how do different linux OSes manage them

All linux distros use some version of the Linux kernel. How the network is managed can vary little to a lot from version to version. There are also local settings for the kernel. Things in sysctl like packet buffer sizes. You also have hardware buffers like the NIC ring buffer/NIC buffer/send/receive queue (I've seen it referred to as all of those) which is set by tools like ethtool. Then you have deeper level settings like congestion algorithms, congestion windows, etc etc. There are entire books written on this. Two of my favorites are Understanding the Linux Kernel and Understanding Linux Network Internals. But to crudely summarize the answer here, the kernel manages all of this for the most part.

> how this packet of data is physically sent over the internet

Basically, buffers and interrupts (hardware/software). These chunks of data sit in a buffer somewhere until either the buffer fills up, and the owner of the buffer sends an interrupt to the kernel saying "hey I need attention, I'm running out of buffer space, can you pick up some packets for me and free up some space?" to software just repeatedly polling a memory address to check for new packets in said buffer. Things like kernel bypass allow userspace programs to read the memory directly on the NIC. But usually a packet goes from the NIC, to the kernel, to the application.

The internet is really just a big conga line of buffers and interrupts. There are tons of places a packet can be dropped. Throughout the process a packet moves through the "7 layers of the OSI model" moving from the physical medium all the way up to the end user application.

The details of how this works are endless. I've literally spent 5 hours in interviews talking about all this and how it works. So like I said your question is pretty huge :)

You might have some better luck if you go top down. Start out with an abstracted view of reality as provided by the computer, and then peel off the layers of complexity like an onion.

I would recommend a "bare metal" approach to programming to start, so C is a logical choice. I would recommend Zed Shaw's intro to C: http://c.learncodethehardway.org/book/

I would proceed to learning about programming languages, to see how a compiler transforms code to machine instructions. For that, the classical text is the dragon book: http://www.amazon.com/Compilers-Principles-Techniques-Tools-Edition/dp/0321486811

After that, you can proceed to operating systems, to see how many programs and pieces of hardware are managed on a single computer. For that, the classical text is the dinosaur book: http://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/1118063333 Alternatively, Tannenbaum has a good one as well, which uses its own operating system (Minix) as a learning tool: http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639/ref=sr_1_1?s=books&ie=UTF8&qid=1377402221&sr=1-1

Beyond this, you get to go straight to the implementation details of architecture. Hennessy has one of the best books in this area: http://www.amazon.com/Computer-Architecture-Fifth-Quantitative-Approach/dp/012383872X/ref=sr_1_1?s=books&ie=UTF8&qid=1377402371&sr=1-1

Edit: Got the wrong Hennessy/Patterson book...

Start here.

Read those left to right. You will learn a lot about networking, a lot about Python and how that is commonly used to hack, and then a lot about Kali Linux. You won't learn how to use the tools, but you will learn what they are.

I would also recommend "Operating System Concepts" but it is a bit pricey. I like that book because it doesn't teach you how to use a bunch of commands in linux, rather it teaches you how operating systems work and why they work that way. Very interesting, and there is an entire section on security. Also, "Penetration Testing" is a good one, and it is cheap too. You will learn how to use some Kali tools, but you'll also learn the important stuff. Buffer overflows and format string attacks are what you need to know how to do. You need to know how to look at and manipulate memory.

If you want to figure out how to do it yourself, read the first four books. If you want a step-by-step guide of exactly what to do, read the last book. It is also pretty important, IMHO, to know a bit about operating systems, but honestly you don't need that one. It just tells you why things are the way they are, which is sometimes helpful when you're like "oh I wonder if I can hack in like this" but then you remember that you could, but they changed it because you could.

Good luck on your endeavors!

Edit: I looked at the sidebar and it agrees with me about learning how OS's work. It says: I think the best place to start is to get a solid understanding of OS concepts first. The combo of Linux, C, and ASM are almost essential to really understanding how everything melts together. I like this resource: http://wiki.osdev.org/Expanded_Main_Page.

I think it's time for you to read a text book about virtual memory and page tables. There's a lot going on under the hood.


The short answer is, every process lives in its own virtual space, which appears to the process to be the whole of system memory. For that process, the only things that exist are its own memory and the kernel parts which are mapped into it. The only way a process can see other process memory is via the kernel.


The longer answer is that the way the kernel achieves is this is through a couple of bits of hardware in particular the MMU (memory management unit) which includes the TLB (translation lookaside buffer). The TLB is a kind of cache that handles fast lookups from virtual addresses (that a process sees), to physical addresses (that the kernel sees and manages). A TLB lookup will fail if a process tries to access a virtual address that is not mapped into it. In this case, the kernel (or on x86, the MMU on behalf of the kernel) will consult a bunch of tables ("page tables") to find the mapping and load it. If the kernel can't find the memory, then your process is trying to access memory that was never allocated to it, and you get a segfault (the memory segment couldn't be found).


There's a lot to it, and a single reddit comment isn't the place to get into all the details. I'd take a look at Modern Operating Systems or any other decent text book for a full explanation.

Good on you for looking to grow yourself as a professional! The best folks I've worked with are still working on professional development, even 10-20 years in to their profession.

Programming languages can be thought of as tools. Python, say, is a screwdriver. You can learn everything there is about screwdrivers, but this only gets you so far.

To build something you need a good blueprint. For this you can study objected oriented design (OOD) and programming (OOP). Once you have the basics, take a look at design patterns like the Gang of Four. This book is a good resource to learn about much of the above

What parts do you specify for your blueprint? How do they go together? Study up on abstract data types (ADTs) and algorithms that manipulate those data types. This is the definitive book on algorithms, it does take some work to get through it, but it is worth the work. (Side note, this is the book Google expects you to master before interviewing)

How do you run your code? You may want to study general operating system concepts if you want to know how your code interacts with the system on which it is running. Want to go even deeper with code performance? Take a look at computer architecture Another topic that should be covered is computer networking, as many applications these days don't work without a network.

What are some good practices to follow while writing your code? Two books that are widely recommended are Code Complete and Pragmatic Programmer. Though they cover a very wide range (everything from organizational hacks to unit testing to user design) of topics, it wouldn't hurt to check out Code Complete at the least, as it gives great tips on organizing functions and classes, modules and programs.

All these techniques and technologies are just bits and pieces you put together with your programming language. You'll likely need to learn about other tools, other languages, debuggers and linters and optimizers, the list is endless. What helps light the path ahead is finding a mentor, someone that is well steeped in the craft, and is willing to show you how they work. This is best done in person, watching someone design and code. Also spend some time reading the code of others (GitHub is a great place for this) and interacting with them on public mailing lists and IRC channels. I hang out on Hacker News to hear about the latest tools and technologies (many posts to /r/programming come from Hacker News). See if there are any local programming clubs or talks that you can join, it'd be a great forum to find yourself a mentor.

Lots of stuff here, happy to answer questions, but hope it's enough to get you started. Oh, yeah, the books, they're expensive but hopefully you can get your boss to buy them for you. It's in his/her best interest, as well as yours!

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.

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

Yeah, I feel much the same way. I just look at the portions that interest me. I am not smart enough to understand all of it, so I just study and try to learn small parts individually. I bought Understanding the Linux Kernel. It is pretty good book. Some of it is over my head, but it covers the 2.6 kernel in depth. I'd recommend it.

Three CS fundamental books in the order I'd suggest someone read them if they don't have a background in CS.

• Modern Operating Systems - Tanenbaum. This, or any good OS book is something that anyone writing software that runs on servers should read. If you happen to only write frontend JS or HTML, you can probably skip it or push it to the end of the list.
  
  
• Design Patterns:
  Elements of Reusable Object-Oriented Software - "Gang of Four". My preferred way to consume this book is to read it lightly, understand the basics of the patterns, and then come back to them individually when you encounter them in the wild or think you want to employ one of them.
  
  
• Algorithms - Sedgewick. If you want a more mathematically rigorous treatment, Introduction to Algorithms - "CLRS" is excellent as well.
  
  
  
  
  Then there are these books that aren't really "CS books", but are geared more twoards practitioners.
  
  
  
• Clean Code - Martin
  
  
• Code Complete - McConnell
  
  
• Working Effectively with Legacy Code - Feathers
  
  
• The Managers Path - Fournier This one might seem like a weird suggestion, but even if you don't have plans to become a manager, it can help with understanding the path to a Tech Lead type of role. You'll also get a good idea of how your boss can and should be helping you, and what you should be asking of them.

http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X

or the previous edition

http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639

Both have a Linux case study after going through the details of what makes an OS.

Your not going to have a RHEL specific book of this nature because a distro like RHEL is a mash of so many different and huge projects that are under constant development. If you want to know the ins and outs of GNOME for instance, you're going to have to delve into the GNOME developer documentation, same with things like Systemd and GLIBC

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!

Firstly, you should pick up a text on Operating Systems. There's a few classics:

• Silbershatz's Operating System Concepts (aka "The Dinosaur Book")
  
• Andrew Tanenbaum's Operating System Design and Implementation (aka "The Minix Book")
  
  That being said, the summarized version (assuming we're talking about pre-emptive multitasking) is that shortly after the OS boots, it initializes the hardware timer with some delay value (1ms is common in modern OS's, but others aren't unheard of). When the hardware timer expires, it issues an interrupt. When a hardware interrupt occurs, the processor will push the instruction pointer, stack pointer, flag registers (and perhaps others) onto the stack and begins executing the code at the address configured for the interrupt.
  
  An OS will have installed an interrupt handler for the timer that will run the task scheduler. In a really simple model, the task scheduler will suspend the currently running task by copying the various registers (flags, instruction pointer, stack pointer, etc) from the stack into memory. It will then select the next task that it wishes to execute and copy its registers onto the stack (replacing what was pushed there initially by the timer interrupt). Finally, it will reset the timer for another delay and will issue an "interrupt return" instruction which will pop the saved-registers off the stack and back into their corresponding locations in the CPU registers. At this point, the previous task is suspended, the new task is running.
  
  If you're feeling adventurous and have access to a microprocessor which has a timer and hardware interrupt support, you can write a fairly simple/naive scheduler yourself with relative ease (I did this on a Motorola HC12 in university for fun).
  
  In practice, a modern OS has a bit more to deal with than just the CPU registers. There might also be a virtual memory sub-system which needs to be updated, many other registers beyond just the IP, SP and flags which need to be saved and restored, etc. Additionally, many OS's have potential complex algorithms to select which task to run based on a variety of considerations: is the task interactive or doing batch work, are we trying to meet real-time scheduling requirements, is there an affinity to a particular CPU core that we want to consider (perhaps there's L2 cache that we like the application to stay close to), etc.
  
  In short: the PC isn't nulled out, it's saved away and then eventually restored.
  
  There's a whole other discussion which could be had about other types of multi-tasking. Co-operative multitasking was common until the mid-90s (System 7 on the Mac was co-operative, for example). In this model, applications need to periodically release control to the operating system. This is done through a system-call (and thus a software interrupt); in the case of the mac, this was WaitNextEvent.

Fungus Cave

Github repository, screenshot.

I'd like to share two things this week. First, I want to expand my C# toolkit, so I searched and purchased two books:

• C# 7.0 in a Nutshell
  
• Programming WPF
  
  I haven't read WPF yet. As for Nutshell, both the price and content is amazing.
  
  Second, I designed and implemented a field of view algorithm. It has following features:
  
  
• It is not so complicated as recursive shadow casting.
  
• Walls do not block LOS, but they make grids which are farther away from the observer darker.
  
• You can easily add more obstacles in addition to walls and light sources.
  
  FOV is processed by three classes:
  
  
• FieldOfView creates a 2D array. Each grid in the array can be of one of three status: Unknown, Visited and InSight. When drawing FOV, the first step is turning all InSight grids to Visited.
  
• RenderSprite is the last step in drawing FOV. Every sprite checks its position in the observer's FOV status array and changes color accordingly: white for InSight, grey for Visited, and black for Unknown.
  
• FOVRhombus reads observer's position as input and changes the FOV status array.
  
  distanceBoard:
  
  > 3 3 3 3 | 3 4 4 4
  
  > 2 2 2 3 | 2 2 # 4
  
  > 1 1 2 3 | 1 1 2 4
  
  > x 1 2 3 | x 1 2 3
  
  FOVRhombus creates another 2D array called distanceBoard. The algorithm changes FOV status in three steps:
  
  
• Starting from observer's position, traverse the whole distanceBoard array and calculate the distance between observer and each grid. If the grid is a wall, push the position into a wallStack.
  
• For each wall in the wallStack, check surrounding grids in a rhombus shape. If distance(grid, observer) is greater than distance(wall, observer), increases the grid's distance by 1 (or any positive number you like.)
  
• For each grid in the distanceBoard, if the value is less than or equals to observer's max sight range, change the corresponding grid in FOV status array to InSight.
  
  Multiple walls cannot make the same grid even darker. If there are multiple obstacles that cast shadow, only the darkest shadow takes effect. If there are light sources, just reduce the distance.
  

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.

​

I got a bookmark folder filled with resources just for the day I choose not being a lazy slob. Here's some:

https://www.kernel.org/doc/html/latest/ - Official docs

http://www.dit.upm.es/~jmseyas/linux/kernel/hackers-docs.html - Resource list including books and webpages

Some books i got from libgen:

Professional Kernel Architecture

Understanding the Linux Kernel, Third Edition

Linux Kernel Development (3rd Edition)

I always find myself looking at man pages while programming in C, the illusion of speed while using Google can be counter-productive -- blog posts are always filled with misinformation that hampers your ability.

I recommend spending quite a bit of time in userland first. In kernel land the stakes are much higher, after all who's going to look after the kernel. To name a few issues:

• 8K stack on 32bit kernels, or 16K stack on 64 bit kernels (I believe it can be changed via a config). This means you need to use vmalloc and kmalloc to have a large array.
  
  
• If you corrupt memory in the kernel, your system will crash.
  
  
• No FPU. Only use integers. Remember you're executing in a process context.
  
  I would start with something very simple, look at the linked-list structure of task_struct and thread_info in <linux/sched.h>
  
  eg:
  
  struct task_struct {
  volatile long state; / -1 unrunnable, 0 runnable, >0 stopped /
  void stack;
  atomic_t usage;
  unsigned int flags; / per process flags, defined below */
  unsigned int ptrace;
  
  

  ifdef CONFIG_SMP
  

    struct llist_node wake_entry;<br />
    int on_cpu;<br />

  };
  
  
  and thread_info
  
  struct thread_info {
  struct task_struct task; / main task structure /
  struct exec_domain exec_domain; / execution domain /
  u32 flags; / low level flags /
  u32 status; / thread synchronous flags /
  __u32 cpu; / current CPU /
  int preempt_count; / 0 => preemptable,
  <0 => BUG /
  };
  
  To learn Linux, or any large software project you need to get your hands dirty. Hack the kernel as you please, after all that's why linux is open source.
  
  Book recomendations:
  
  Linux Kernel Development
  
  Modern Operating Systems
  
  Have fun hacking!

Get the Python Essential Reference by David Beazley. I was in the same boat as you several years ago. I probably read 5-6 python books that were aimed at experienced developers, Dave's book is BY FAR the best that I found.

He just started working on the 5th edition, so the 4th edition is getting a little long in the tooth (python 3 was a new thing back then), but I can still whole-heartedly recommend it.

Operating Systems Concepts (AKA The Dinosaur Book) is generally quite well regarded.

Artificial Intelligence: A Modern Approach tends to be the text of choice for teaching AI to undergraduates - it doesn't deal with many of the most modern techniques, but it establishes the common functionalities.

The dinosaur book

As you can imagine, the kernel is a gigantic project, so it's hard to jump in and understand how things are working. If this is your first exposure to any operating system stuff, I would suggest backing up and learning a bit more of the basics. You'll find information like that under the terms "computer architecture" and "computer organization". Modern Operating Systems by Tanenbaum is a classic read to get started.

If you really want to dig at the kernel code, I'd recommend Robert Love's Linux Kernel Development. It gets into the details of process scheduling, interrupts, memory management, file systems, etc. and looks at the code. But I'd warn you that it's pretty complex and can be quite slow to learn.

There are a few free linux kernel books online such as Advanced Linux Programming and Linux Device Drivers. Even if some of the information is outdated, you'll get a lot of information about how the kernel works in general from these resources.

Hope that helps, and enjoy.

Linux Programming Interface (https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200)

https://www.amazon.com/Practical-Vim-Thought-Pragmatic-Programmers/dp/1934356980

This and this by Tanenbaum are the best books on the topic i have read until now.

It’s gonna be hard to give you much without picking a specific OS—details can vary widely even within a single OS family line—but an OS book is probably a good place to start. Tanenbaum’s book is the go-to.

Alternatively, there are books on specific techniques like garbage collection, or books more generally on programming for UNIX/POSIX/Linux or Windows (via Win16/32/64 API, not the six-mile-high shitheap piled atop), which would tell you some about how memory management works in down at least to whatever abstract hardware interface the kernel uses.

No, and I'll tell you why. Arch isn't a horrid distro, I just don't like the Arch philosophy or mentality that a lot of the newbies have. People use Arch for the wrong reasons, mainly "to learn Linux", which kinds grinds my gears. Hell, I just had this talk with someone today so it's kinda fresh in my mind.

• Some people think you get a "performance" gain from switching. The only distro I know that you can get that claim is Gentoo, and it's minimal compared to the hassles inherited in getting the system up and running (last time I touched Gentoo was 2005).
  
  
• Rolling Release sounds nice until a tool that you have been using for ages goes away (ifconfig, route). I want stability and the choice to not upgrade to the latest and greatest, especially on teh server side (sarge has been keeping one of my sites up and running for ages and never had an issue)
  
  
• "Learning Linux" is misleading. I hear this a lot, and it's malarkey. Any distro can "teach you linux". Just because your installation is a hassle doesn't mean you are a good teacher. If you want to learn how a distro works, Linux From Scratch is a way better project. Other than that Learning Linux, for the average user, should be centralized to knowing your system in a high level AND understanding your CLI and Shell
  
  Also, if you want to learn OS concepts, read Operating Systems Concept by Silberschatz or Modern Operating Systems by Tanenbaum, both better sources of learning what an OS does than Arch.
  
  My final word before I get downvoted to oblivion, just because something is harder than it should be doesn't mean it's a good educational tool. If that were true, you'd be using a BSD derivative over Arch Linux.

• Kernel developer reference: FreeBSD Device Drivers
  
• System Administration reference: The FreeBSD Handbook
  
• Developer reference: Advanced Programming in the UNIX Environment
  
• Developer reference: UNIX Network Programming

The Hillegass book is kinda the Cocoa bible. Clicky.

I disagree with the suggestions of podcasts, videos, and developer documentation. You really need to start here:
Cocoa(R) Programming for Mac(R) OS X

It's definitely not too late to pick up it up! For learning Objective-C itself, I highly recommend Programming in Objective-C 2.0 by Stephen Kochan; I used that book without any prior C knowledge at all and it was very easy to follow. Even if you feel you know the language pretty well, it's nice to have as a reference.

If you're more of a visual learner, this course here by Stanford on iOS programming is really good and covers everything from Objective-C and memory management right up to multithreading and OpenGL ES (plus it's free).

When you begin spending a decent chunk of time actually writing iPhone apps, the iOS Reference Library is going to become your best friend. It has a ton of guides and sample code all written and kept up-to-date by Apple. For starters, I'd recommend perhaps reading the sections under the "Required Reading" section (namely, the iOS Application Programming Guide, the iOS Development Guide and the iPhone Human Interface Guidelines (HIG for short). If you want all of the information on one single page, click on the .PDF button in the top right corner and you'll get just that. A couple of things which aren't listed on the Required Reading section but I think are worth having a look at are the Cocoa Fundamentals Guide and Apple's own introduction to Objective-C 2.0.

To give you a quick answer to the language-vs.-library question, the language is what you'll be using to manage memory, create loops, create methods and all that jazz, whereas the library is a collection of software which Apple has written to make your life easier. An example is a UITableView, a class written by Apple which only requires a few methods to be filled out and a basic data source, which will give you a scrollable view almost identical to the one found in the iPod app or even Settings app. It's a powerful class but extremely easy to set up if you just want the basics. I'm hoping that slightly cleared things up a bit, but if not, feel free to PM me some questions or even post them here for everybody else to see and learn from. I'm definitely no guru on this stuff, but I'll do my best to help.

I'm a graduating senior studying computer science. Last semester I took an intense C course (Advanced Programming in C and C++ (Spring 2014 course page)). The majority of the class focused on C, with the last few weeks introducing C++ concepts such as the built-in data structures and templating. The hardest project was writing a web server in C, and although you probably won't be doing anything like that, I recommend you dive into these books alongside K&R:

Advanced Programming in the UNIX Environment, Third Edition. Can be pricy, but you may be able to find this online if you know where to look. I recommend you have a hard copy as a reference manual though.

Learn C The Hard Way. Say what you want about Zed Shaw, but I worked through this book alongside K&R just before I started Advanced Programming and really liked the way he takes you through the C fundamentals. The book is free in HTML form, or you can opt to buy the eBook.

Hope that helps!

So, when I was younger, I did attend one computer science related camp,

https://www.idtech.com

They have a location at Emory (which I believe I did one year) that was ok (not nearly as "nerdy"), and one at Boston which I really enjoyed (perhaps because I had to sleep on site). That being said, the stuff I learned there was more in the areas of graphic design and/or system administration, and not computer science. They are also quite expensive for only 1-2 weeks of exposure.

I felt it was a good opportunity to meet some very smart kids though, and it definitely lead me to push myself. Knowing and talking to people that are purely interested in CS, and are your age, is quite rare in high school. I think that kind of perspective can make your interests and hobbies seem more normal and set a much higher bar for what you expect for yourself.

On the other side of things, I believe that one of the biggest skills in any college program is an openness to just figure something out yourself if it interests you, without someone sitting there with you. This can be very helpful in life in general, and I think was one of the biggest skills I was missing in high school. I remember tackling some tricky stuff when I was younger, but I definitely passed over stuff I was interested in just because I figured "thats for someone with a college degree". The fact is that experience will make certain tasks easier but you CAN learn anything you want. You just may have to learn more of the fundamentals behind it than someone with more experience.

With that in mind, I would personally suggest a couple of things which I think would be really useful to someone his age, give him a massive leg up over the average freshman when he does get to college, and be a lot more productive than a summer camp.

One would be to pick a code-golf site (I like http://www.codewars.com) and simply try to work through the challenges. Another, much more math heavy, option is https://projecteuler.net. This, IMO is one of the best ways to learn a language, and I will often go there to get familiar with the syntax of a new language. I think he should pick Python and Clojure (or Haskell) and do challenges in both. Python is Object Oriented, whilst Clojure (or Haskell) is Functional. These are two very fundamental and interesting "schools of thought" and if he can wrap his head around both at this age, that would be very valuable.

A second option, and how I really got into programming, is to do some sort of web application development. This is pretty light on the CS side of things, but it allows you to be creative and manage more complex projects. He could pick a web framework in Python (flask), Ruby (rails), or NodeJS. There are numerous tutorials on getting started with this stuff. For Flask: http://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world. For Rails: https://www.railstutorial.org. This type of project could take a while, there are a lot of technologies which interact to make a web application, but the ability to be creative when designing the web pages can be a lot of fun.

A third, more systems level, option (which is probably a bit more opinionated on my part) is that he learn to use Linux. I would suggest that he install VirtualBox on his computer, https://www.virtualbox.org/wiki/Downloads. He can then install Linux in a virtual machine without messing up the existing OS (also works with Mac). He COULD install Ubuntu, but this is extremely easy and doesn't really teach much about the inner workings. I think he could install Arch. https://wiki.archlinux.org. This is a much more involved distribution to install, but their documentation is notoriously good, and it exposes you to a lot of command line (Ubuntu attempts to be almost exclusively graphical). From here, he should just try to use it as much as possible for his daily computing. He can learn general system management and Bash scripting. There should be tutorials for how to do just about anything he may want. Some more advanced stuff would be to configure a desktop environment, he could install Gnome by default, it is pretty easy, but a lot of people really get into this with more configurable ones ( https://www.reddit.com/r/unixporn ). He could also learn to code and compile in C.

Fourth, if he likes C, he may like seeing some of the ways in which programs which are poorly written can be broken. A really fun "game" is https://io.smashthestack.org. He can log into a server and basically "hack" his way to different levels. This can also really expose you to how Linux maintains security (user permissions, etc. ). I think this would be much more involved approach, but if he is really curious about this stuff, I think this could be the way to go. In this similar vein, he could watch talks from Defcon and Chaos Computer Club. They both have a lot of interesting stuff on youtube (it can get a little racy though).

Finally, there are textbooks. These can be really long, and kinda boring. But I think they are much more approachable than one might think. These will expose you much more to the "Science" part of computer science. A large portions of the classes he will take in college look into this sort of stuff. Additionally, if he covers some of this stuff, he could look into messing around with AI (Neural Networks, etc.) and Machine Learning (I would check out Scikit-learn for Python). Here I will list different broad topics, and some of the really good books in each. (Almost all can be found for free.......)

General CS:
Algorithms and Data Structures: https://mitpress.mit.edu/books/introduction-algorithms
Theory of Computation: http://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
Operating Systems: http://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720

Some Math:
Linear Algebra: http://math.mit.edu/~gs/linearalgebra/
Probability and Stats: http://ocw.mit.edu/courses/mathematics/18-05-introduction-to-probability-and-statistics-spring-2014/readings/

I hope that stuff helps, I know you were asking about camps, and I think the one I suggested would be good, but this is stuff that he can do year round. Also, he should keep his GPA up and destroy the ACT.

Assembly Language Step By Step: Programming In Linux

Sure beats the hell out of DINOSAURS?!

1. Understanding the Linux Kernel
   
2. http://www.tldp.org/LDP/lkmpg/2.6/html/
   
3. also relevant: http://eudyptula-challenge.org/

In the interim, I suggest the following books:

• Digital Design and Computer Architecture, by Harris & Harris - covers the circuitry & hardware logic used in computers. Should also cover how data is handled on a hardware level - memory's a bit rusty on this one, and I can't find my copy of it right now. Recommend that you read this one first.
  
  
• Computer Organization and Design, by Patterson & Hennessy - covers the conversion of system code into assembly language, which itself turns into machine language (in other words, covers the conversion of programs from operating system code into hardware, "bare metal" code). Knowledge of digital circuitry is not required before reading, but strongly recommended.
  
  
• Operating System Concepts, by Silberschatz, Galvin & Gagne - covers all the basic Operating System concepts that each OS today has to consider and implement. While there are Linux-based ones, there are so many different Linux "flavors" that, IMO, a book that covers a specific Linux base (called a Linux kernel) exclusively would be incomplete and fail to address all the key aspects you'll find in modern OSes. Knowledge of coding is required for this one, and therefore should be read last.
  
   
  
  As for the coding books, I suggest you pick one up on Python or Java - I'm personally biased towards Python over Java, since I think Python's syntax and code style looks nicer, whereas Java makes you say pretty much everything you're doing. Both programming languages have been out for a long time and see widespread usage, so there's plenty of resources out there for you to get started with. Personally, I'd suggest going with this book for Java and this book for Python, but if you go to Coursera or Codecademy, you might be able to get better, more interactive learning experiences with coding.
  
  Or you can just skip reading all of the books I recommended in favor of MIT's OpenCourseWare. Your choice.

Honestly, you are never going to find a way to shortcut you out of this situation. No one answer is going to be perfect and get you from A to B if your already at C. I had a similar experience with programming and web development.

I studied computer networking all my adult life and never thought I would be developing as my career at the moment. It is the burden of knowing too much and not having a clear direction. What I needed was more confidence in my skills which can only really develop over the years through experience.

You say you already know a lot of Linux and Bash concepts. CD/CI pipelines try to abstract a lot of OS related involvement since your code doesn’t need to know how low level kernel operations are happening.

What it sounds like you need is knowledge of OS concepts, not just Linux concepts. I say this because every OS has its own way of doing the same thing one way or another.

For example virtual memory, if you understand the concept of virtual memory in any OS rather than a specific OS’s semantics regarding Virtual memory then I think you would be better off in the long run.

If I am wrong and you are the master of the Linux environment, I believe you just need to deep dive into development strategies and the core principles of CD/CI. Once you have a foundation it doesn’t really mater if you are a Jenkins expert or CircleCI expert, all that matters is if you have a foundation to fall back on.

Edit: if you wanted my two cents on material here are some books I recommend.

The Practice of System and Network Administration

Operating Systems Concepts

UNIX and Linux System Administration Handbook

I've heard good things about "The Linux Programming Interface"

"Modern Operating Systems" like others suggested is also fantastic.

I'd recommend reading Practical Programming: An Introduction to Computer Science Using Python. I would read each chapter two or three times, and supplement it with online help. Do all the exercises at the end. If you don't understand something, feel free to ask in compsci (or send me a private message!).

I always use this book when trying to teach someone the basics of programming. Python is very easy to learn, relevant, and powerful. The book is brief, well written, and it'll semi introduce you to the command line (which will become your best friend).

You should try and build yourself a Linux computer to learn programming on. If you have a mac, that would be an OK substitute. I would use windows as a last choice- it can be a decent development environment but requires lots of software to set up. Programming can certainly be done in windows, but Linux will offer you a decent development environment right out of the box. I'd recommend Ubuntu for beginners. Macs come with a lot of the same facilities that linux comes with (python and other languages pre-installed, a relevant command line environment, etc), windows comes with almost none. If you study computer science in college, you'll use lots of linux- a head start will help.

For a text editor, try and become familiar with vim or emacs, both of which come with most linux distros. If you find them too overwhelming, you could use a graphical editor instead and still be ok. On the mac, you can get macvim. As a programmer, I regret my lack of knowledge in vim. If you're on windows, just stick with something like notepad++.

If you become an ace at python, and really enjoy the concepts, The Linux Programming Interface will take you a (very) long way. It may seem overwhelming, but it covers many deep aspects of computing. Learning C will really help you the most in the long run (because of it's intimate relationship with the operating system and computer memory), but it is not an easy beginner language. If you don't understand the concepts in C (may be difficult from just a book), you may try your hands at either C# or Java (as they're both very widely used).

Keep in mind that no one becomes a programmer (or hacker, if you will) over night. I'm in CS grad school, and started programming over 5 years ago- it's just now starting to all make sense. The amount of conceptual information in computer science is tremendous, and it will take a long time to master. Welcome to the rabbit hole =)

P.S. - Learn to type the correct way without looking at the keyboard. Speed isn't that big of an issue so long as you can hit a consistent ~60 wpm.

I've found The Linux Programming Interface to be one of the best in-depth books I've ever tried to read on Linux. Only issues with it is it's not too hands-on, so it's a bit difficult to retain, and maybe the price, bit would have to say it's still totally worth it.

"Linux Kernel Development 3rd Edition" is fairly modern (2010) and really good:

http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468/ref=sr_1_1?ie=UTF8&qid=1413858907&sr=8-1&keywords=linux+kernel+development

Also... not kernel internals specific but an AMAZING book about programing against the linux kernel is "The Linux Programming Interface":

http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200/ref=pd_sim_b_4?ie=UTF8&refRID=1X9Y7ZM18JWKJ80PNXN3

It was written by the guy who wrote a lot of the linux man pages and is one of the best books about how linux works from a programming interface perspective that I've ever read.

The Linux Programming Interface, by Michael Kerrisk -- hands down the unsurpassed resource if you want to understand Linux.

you can start by grabbing The Linux Programming Interface book.

https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X

Every sysadmin must read a https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X . This book teaches what operating system is, how it works and why specific decisions were made when people designed parts of it. Some programming knowledge required to get more from this book, but it's mandatory in the IT field now anyway. Reading this book really extended my troubleshooting capabilities as I got a clearer picture of how things work in my head.

First, welcome to the indie community! I'd recommend to start designing a small PoC. Grab some sheets of paper and start drawing your app's different views and interactions. The purpose of this is to clarify your ideas. At the beginning, that's all you need. Once you have something you think is "usable", then, just then, move to coding - it'll save you a lot of time. Just as a reference, I spent 7 months designing Memorigi 1.0 (no coding, just drawings).

​

How much programming you need? Well, there's no "right amount" IMO. If you want to go Java path, I recommend this book Android Programming: The Big Nerd Ranch Guide (https://www.amazon.com/Android-Programming-Ranch-Guide-Guides/dp/0134706056/ref=sr_1_2?ie=UTF8&qid=1551068980&sr=8-2). If however, you take Kotlin path this is my recommendation Kotlin in Action (https://www.amazon.com/Kotlin-Action-Dmitry-Jemerov/dp/1617293296).

​

One last advice, start small, then grow from there. Don't try to have your app fully complete in one pass. It's a recipe for discouragement and disaster. DM me if at some point you feel stuck and I'll do my best to help you.

​

Cheers!

JavaScript is weird, right enough, but it's the language of the web. If your idea involves a website, even a mobile web site, then JavaScript is the only way to go.

If your only target is Android devices, then you want Java. Java and JavaScript sound related, but they have nothing to do with each other. Java is a bit of a beast, and not the easiest thing to teach yourself, but it's the backbone of Android. It's also a hugely employable skill in Glasgow, with all the banks and financial services building their systems in Java or C# (Microsoft's own very similar version of Java).

CodeClan just opened in Glasgow in January. It's a 16-week course in software development, including modules in Java, Android and JavaScript, and the main purpose is not just to teach these things but to put people into jobs doing these things. It's not cheap and it's a full-time commitment, but it can be covered with a careers development loan and your job prospects on leaving are awesome. Full disclosure: I work here. Our next course starts in September.

If that's not for you, freeCodeCamp is a worldwide network of self-teaching coder newbies, and they have a Glasgow chapter that meets fairly regularly.

Apart from that, you're on your own. There are plenty of sources for learning JavaScript solo, but the best I've seen is JavaScript30. It doesn't start from scratch, so follow the Learn JavaScript track of Codecademy for the basics.

For Java, yeah there are freebie courses out there but they're mostly shite. I would recommend the books Head First Java followed by the Big Nerd Ranch Guide for Android.

Get a programming language, but also get some literature on the theories that programming uses. A book on algorithms and another on data structures would pretty much do the trick.

And why start with Python when you can start with C and then move onto java? I am sure you are a smart guy, and understanding those 2 languages will give you the lingua franca you need to comprehend the best textbooks/references on advanced programming concepts that will help you out.

I suggest:

1 Get this http://en.wikipedia.org/wiki/The_C_Programming_Language

2 Install linux (ubuntu probably is the way to go), you'll probably dual boot

3 Get this http://www.amazon.com/Unix-Programming-Environment-Prentice-Hall-Software/dp/013937681X

4 Learn your shell (the bash shell), learn how to use C, sed, awk, regex etc. These are all super-useful tools. This is an entirely approachable set of topics, don't be daunted.

After doing all of that it is time to get to java.

1: Pick up Head First Java (and download all of the book exercises from the publisher's website. This will be your first book in java.

2: Download all java docs from Oracle (so you can reference them).

3: Pick up Thinking in Java by Bruce Eckel (this will be your other Java book to learn from).

All of this should more than occupy your 6 months. After this you'll be ready to learn some more advanced concepts with these as your solid foundations. If you want to play with databases (a good idea) and integrate them into your programming then check out SQLLite.

http://sql.learncodethehardway.org/

In addition, he co-wrote The UNIX Programming Environment and The Practice of Programming with Rob Pike and The Elements of Programming Style with PJ Plauger. I've never read the Practice of Programming (add it to the wish list) but the other two books are fantastic. The Elements of Programming Style is somewhat dated (code is in PL/I and Fortran, and it discourages things like goto which we all already know is bad) but a lot of it is still relevant and worth picking up a used copy if you can find it.

I believe this book would be of interest, its big and bad, but from memory it is exactly what you are looking for, infact it basically gives you all you need to know to start implementing your own fully featured shell:https://www.amazon.co.uk/Advanced-Programming-UNIX-Environment-Addison-Wesley/dp/0201433079


EDIT: Seems there is a new edition, it is over 25 years old and has been updated multiple times to cover new standards so this one is probably better, https://www.amazon.co.uk/Programming-Environment-Addison-Wesley-Professional-Computing/dp/0321637739/ref=dp_ob_title_bk

1. You should learn Objective-C. Start with Learning Objective-C from the Developer site, and follow the rabbit trail to other documents. Also, read up on iOS Application Design
   
   
2. Yes. You can register your app to be woken up in case of a significant location change. Or, you can register your app for continuous location updates in the background, which will kill the user's battery if not used correctly. See Executing Code in the Background.
   
3. It may be easier for you to pick up Cocoa programming on the Mac before going to the iPhone. Pick up Aaron Hillegass's excellent Cocoa Programming for Mac OSX and read the first five chapters. (I noticed that Hillegass has produced a new iPhone Programming textbook. I haven't read it but it has good reviews).

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.

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

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.

Somebody else recently asked the same question,
might find some tips there...

tl;dr learn Python.

Edit: I'm also teaching myself and after messing around with a few languages and books and reading a lot of proggit, programming blogs and looking around the job market for where I will be living in a few years, I've gone with C#.

Why?

Because it seems that to get a foot in the door as a junior developer these days, not being a university graduate and not coming from an IT background, I would need some sort of certification. That leaves Java and C# and from what I've read here and elsewhere, the state of Java is deplorable these days, so...

Also, I was struggling with the object oriented model. So I reasoned that if I can become certified in a language that is based on that model, I will absolutely have to know it, a sink or swim sort of thing. Then I can move on to one of the more "open" languages more easily should I desire to.

I'm learning from this book, which has been fantastic, as the Head First series are presented in a different way to most others, for totally visual learners like myself who have trouble conceptualising abstract ideas from screeds of text.

Read here: http://www.advancedlinuxprogramming.com/


Program. Then read here: http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468


Program some more. Then maybe read here: http://www.amazon.com/Linux-Device-Drivers-3rd-Edition/dp/0596005903


And program some more. Yes, I know two of the links are to amazon. I'm sure if you look real hard you can find other formats.

If you're not a beginner, Dave Beazley's book is a great python reference. Also possibly good is Doug Hellmann's book which is derived from his excellent Python Module of the Week website. The kindle version of his book has bad formatting problems, but the print book may be OK.

• Python Essential Reference (4th edition): David Beazley
  
  
• Violent Python: A Cookbook for Hackers, Forensic Analysts, Penetration Testers and Security Engineers
  
  
• Grey Hat Python: Python Programming for Hackers and Reverse Engineers
  
  
• Python in a Nutshell, 2nd edition
  
  
• Python 3 Object Oriented Programming
  
  
• Invent Your Own Computer Games with Python, 2nd edition
  
  
• Core Python Applications Programming (3rd edition) (core series)
  
  
• Making Games with Python & PyGame
  
  
  
  
  
  
  
  
  
  
  
  
  

A note re: jumping into The Linux Kernel -- This is best tackled while simultaneously reading a book on the kernel like Linux Kernel Development (3rd Edition) by Robert Love and a book on general *nix fundamentals like Advanced Programming in the Unix Environment by Stevens and Rago.

two of mine were The Design of the UNIX Operating System and Advanced Programming in the UNIX Environment

one of the other big things was some original unix documentation. I cant recall the name of them but there were small paperback book released early on for unix describing how to use and program for it. I remember someone linkijg to it either on reddit or hn a couple months ago.

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.

To learn about the user space APIs
A good intro to the inner workings
A fairly detailed reference of the inner workings

Head First C# is a great book. That, and C# in a Nutshell taught me everything I needed to know.

> I have been using sublime for a while now. And I love it, it's intuitive and beautiful. But I feel like I should really vi or vim, for ssh sessions and so on. I know that there are ways to use sublime to edit codes over ssh, but I feel like I am not a real programmer if I don't know vi.

I'm pretty sure there are a lot of excellent programmers who don't know vim. Furthermore sublime is an excellent editor, if you like it there's no need to change.

BUT:

• Even if you stick with Sublime or use an IDE I would still highly recommend you learn vim. Sublime as well as many IDEs have plugins with which you can use the vim modal-editing commands. Starting out this will be a bit of a pain to use. But after a relatively short amount of time you will be editing faster than you ever did, and the speed only increases with time/learning. This is a huge benefit, even if you never use vim itself but only editors that support its commands.
  
  
• Just spoonfeed yourself the commands over time and really use them instead of trying to memorize heaps of them in a short timeframe. Start with the basics and add to that step by step. Make sure you continue to correct yourself and keep being aware of more efficient ways of doing things. It's about slowly/progressively building better habits.
  
  
• Text editing in 'modeless' editors will start to feel extremely frustrating once you get used to the ease and speed of vim. Not having to reach for the mouse, the modifier keys or the arrow keys all the time is an enormous advantage both on the speed of your coding as well as your hand health.
  
  
• Make sure you remap the capslock key to either 'esc' or 'control'. Better yet, map both to capslock at the same time ;) (xcape)
  
  
• You need to be able to touch type in order to benefit from vim, so if you can't already I suggest you learn to touch type before you start with vim. I found this to be a very good course.
  
  > Do any of you have resources that explain the why the keystrokes of vi the way they are so I can understand them? For example, why the hell "y" for copy. And any webpages that i can just ctrl-F to search for a command I want? I am planning to have this webpage open up on the side as I do my coding.
  
  

1. Vim doesn't use the 'normal' key commands because it works with different modes, most of the time you want to be in 'normal mode' to navigate and edit your text efficiently. Only enter insertion mode if you need to. Because there are different modes vim allows you to edit text with as little effort as possible because you don't have to use modifier keys all the time and text navigation becomes a breeze. ('y' is much easier on the hands than 'ctr-f') furthermore vim allows most of the commands to work together with other commands. This would be far more difficult if the modifiers had to be used all the time. For example: 'w' means navigate to the beginning of the next word' and 'd' means delete. Both can be used together so you get 'dw' wich means 'delete until the beginning of the next word. The way vim allows you to combine commands is a really powerful feature.
   
2. Begin by typing 'vimtutor' in the terminal and complete that tutorial.
   
3. There are many online resources, but I highly recommend the book Practical Vim both for the quality information it contains as well as how the book is layed out. Each chapter covers an important topic, starts with the basics and delves further and further into the material. So if you're starting out you can just read the start of each chapter, then as you progress you can "go deeper" and pick up more useful commands and tricks as you grow.
   
4. It's been mentioned already but I also quite liked Vim Adventures!
   
   

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.

Well in that case, if you haven't already make sure to look into Computer Architecture, Assembly Language (I don't recommend actual assembly try something like MIPS), and Digital Logic. Those all really helped me when I was learning OS's and stuff past trivial C programs. Keep in mind that they rarely DIRECTLY helped me, moreso they helped me to understand some of the more advanced topics that build on the lower levels of the system. They should help you to understand more of control flow down to the instruction level and help you to understand why some solutions are implemented through hardware and some through software.

With all that said, my recommendation is really cliche. But if you want to learn advanced operating system concepts then I recommend: Modern Operating System Concepts.

That is a newer edition but you'd be fine going with a cheaper used edition that's older. If it's not sold out this link on thriftbooks is a good place to look. Second Edition

Master this and you'll become a ninja :

• https://www.google.com/search?q=top+sysadmin+linux+books&oq=top+sysadmin+linux+books because google is your (false ?) friend
  
• http://www.tldp.org/LDP/abs/html/ because bash is the default
  
• http://zsh.sourceforge.net/Doc/Release/zsh_toc.html because bash sucks
  
• https://www.kernel.org/doc/man-pages/ because it will/should be your most used command after ls and cd and because RTFM
  
• https://wiki.archlinux.org/ because I use it nowadays, it's a great distro and their wiki pages are great
  
• http://www.vim.org/docs.php because it's the default
  
• https://www.python.org/ because python won over perl
  
• http://shop.oreilly.com/product/0636920026891.do because Linux is written mostly in C and because a lot of O'Reilly books are great
  
• http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X because what is an OS ?
  
• http://www.brendangregg.com/index.html because this man kicks ass !
  

I've posted this before but I'll repost it here:

Now in terms of the question that you ask in the title - this is what I recommend:

Job Interview Prep

1. Cracking the Coding Interview: 189 Programming Questions and Solutions
   
2. Programming Interviews Exposed: Coding Your Way Through the Interview
   
3. Introduction to Algorithms
   
4. The Algorithm Design Manual
   
5. Effective Java
   
6. Concurrent Programming in Java™: Design Principles and Pattern
   
7. Modern Operating Systems
   
8. Programming Pearls
   
9. Discrete Mathematics for Computer Scientists
   
   

   Junior Software Engineer Reading List
   

   
   

   Read This First
   

   
   

10. Pragmatic Thinking and Learning: Refactor Your Wetware
    
    

    Fundementals
    

    
    

11. Code Complete: A Practical Handbook of Software Construction
    
12. Software Estimation: Demystifying the Black Art
    
13. Software Engineering: A Practitioner's Approach
    
14. Refactoring: Improving the Design of Existing Code
    
15. Coder to Developer: Tools and Strategies for Delivering Your Software
    
16. Perfect Software: And Other Illusions about Testing
    
17. Getting Real: The Smarter, Faster, Easier Way to Build a Successful Web Application
    
    

    Understanding Professional Software Environments
    

    
    

18. Agile Software Development: The Cooperative Game
    
19. Software Project Survival Guide
    
20. The Best Software Writing I: Selected and Introduced by Joel Spolsky
    
21. Debugging the Development Process: Practical Strategies for Staying Focused, Hitting Ship Dates, and Building Solid Teams
    
22. Rapid Development: Taming Wild Software Schedules
    
23. Peopleware: Productive Projects and Teams
    
    

    Mentality
    

    
    

24. Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency
    
25. Against Method
    
26. The Passionate Programmer: Creating a Remarkable Career in Software Development
    
    

    History
    

    
    

27. The Mythical Man-Month: Essays on Software Engineering
    
28. Computing Calamities: Lessons Learned from Products, Projects, and Companies That Failed
    
29. The Deadline: A Novel About Project Management
    
    

    Mid Level Software Engineer Reading List
    

    
    

    Read This First
    

    
    

30. Personal Development for Smart People: The Conscious Pursuit of Personal Growth
    
    

    Fundementals
    

    
    

31. The Clean Coder: A Code of Conduct for Professional Programmers
    
32. Clean Code: A Handbook of Agile Software Craftsmanship
    
33. Solid Code
    
34. Code Craft: The Practice of Writing Excellent Code
    
35. Software Craftsmanship: The New Imperative
    
36. Writing Solid Code
    
    

    Software Design
    

    
    

37. Head First Design Patterns: A Brain-Friendly Guide
    
38. Design Patterns: Elements of Reusable Object-Oriented Software
    
39. Domain-Driven Design: Tackling Complexity in the Heart of Software
    
40. Domain-Driven Design Distilled
    
41. Design Patterns Explained: A New Perspective on Object-Oriented Design
    
42. Design Patterns in C# - Even though this is specific to C# the pattern can be used in any OO language.
    
43. Refactoring to Patterns
    
    

    Software Engineering Skill Sets
    

    
    

44. Building Microservices: Designing Fine-Grained Systems
    
45. Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools
    
46. NoEstimates: How To Measure Project Progress Without Estimating
    
47. Object-Oriented Software Construction
    
48. The Art of Software Testing
    
49. Release It!: Design and Deploy Production-Ready Software
    
50. Working Effectively with Legacy Code
    
51. Test Driven Development: By Example
    
    

    Databases
    

    
    

52. Database System Concepts
    
53. Database Management Systems
    
54. Foundation for Object / Relational Databases: The Third Manifesto
    
55. Refactoring Databases: Evolutionary Database Design
    
56. Data Access Patterns: Database Interactions in Object-Oriented Applications
    
    

    User Experience
    

    
    

57. Don't Make Me Think: A Common Sense Approach to Web Usability
    
58. The Design of Everyday Things
    
59. Programming Collective Intelligence: Building Smart Web 2.0 Applications
    
60. User Interface Design for Programmers
    
61. GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos
    
    

    Mentality
    

    
    

62. The Productive Programmer
    
63. Extreme Programming Explained: Embrace Change
    
64. Coders at Work: Reflections on the Craft of Programming
    
65. Facts and Fallacies of Software Engineering
    
    

    History
    

    
    

66. Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software
    
67. New Turning Omnibus: 66 Excursions in Computer Science
    
68. Hacker's Delight
    
69. The Alchemist
    
70. Masterminds of Programming: Conversations with the Creators of Major Programming Languages
    
71. The Information: A History, A Theory, A Flood
    
    

    Specialist Skills
    

    
    In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.
    
    

72. Peter Norton's Assembly Language Book for the IBM PC
    
73. Expert C Programming: Deep C Secrets
    
74. Enough Rope to Shoot Yourself in the Foot: Rules for C and C++ Programming
    
75. The C++ Programming Language
    
76. Effective C++: 55 Specific Ways to Improve Your Programs and Designs
    
77. More Effective C++: 35 New Ways to Improve Your Programs and Designs
    
78. More Effective C#: 50 Specific Ways to Improve Your C#
    
79. CLR via C#
    
80. Mr. Bunny's Big Cup o' Java
    
81. Thinking in Java
    
82. JUnit in Action
    
83. Functional Programming in Scala
    
84. The Art of Prolog: Advanced Programming Techniques
    
85. The Craft of Prolog
    
86. Programming Perl: Unmatched Power for Text Processing and Scripting
    
87. Dive into Python 3
    
88. why's (poignant) guide to Ruby

Andrew Tanenbaum's book is often used in college courses. It describes what services an operating system has to provide, different options in terms of overall structure, etc. It doesn't necessarily tell you the practical side of writing one (as far as I remember). Anyhow, the book would probably be a good place to start.

Both Advanced Programming in the Unix Environment and volume 1 of Unix Network Programming are out in updated editions by other people. (Stevens has unfortunately died.)

If you're into paper:

• Linux in a Nutshell is a handy quick reference
  
• A Practical Guide to Linux Commands, Editors, and Shell Programming by Sobell is a great guide for getting to know and use the command line.

Read Clean Code and build a non trivial project using the principles from that book. You'll learn a lot.

Maybe read an Operating Systems book, pick a subsystem you find interesting and try to understand how Linux implements it.

Learn about git and source control.

Contribute to open source projects you find interesting.

Try setting up a server and configuring it to do cool stuff.

Basically, identify something that you don't know much about and dive deeper, or just write lots and lots of code.

A good starting point for studying OS is Tanenbaum's Modern Operating Systems, but of course there are other, more detailed resources.

From OP:

>The exact four books I read are:

>Learning Obj-C

>Learning Java

>iOS Programming: The Big Nerd Ranch Guide

>Android Programming: The Big Nerd Ranch Guide

>However, I would now recommend learning Swift instead of Obj-C. At the time when I was looking into iOS books, good books on Swift were few and far between.

From u/AlCapwn351 in regards to other sources to learn from:

>www.codeacademy.com is a great site for beginners (and it's free). It's very interactive. W3schools is good for learning stuff like JavaScript and HTML among other things.

>When you get stuck www.stackoverflow.com will be a lifesaver. Other than that, YouTube videos help and so do books. Oh and don't be afraid to google the shit out of anything and everything. I feel like an early programmers job is 90% google 10% coding.

>Edit:

>It's also good to look at other peoples code on GitHub so you can see how things work.

Buy an Android book and read that in class instead of following his bullsht.

Last time i checked this book was nice, if you are really interested: https://www.amazon.com/Android-Programming-Ranch-Guide-Guides/dp/0134706056

If you prefer a book: Android Programming: The Big Nerd Ranch Guide (3rd Edition)

If you're starting completely from scratch (no programming knowledge at all), then learn Java. Intro to Java Programming is a pretty good and in depth book. Chapters 1-13 should be good enough to get started with Java programming.

If you want something faster or just need a refresher, than the Java tutorials from TutorialsPoint could work.

Other wise, if you already know Java, the BNR Android Programming book is a really good book for Android programming. It covers a lot of topics; the basics all the way to the more advanced, real world applications.

The Android Developers site is incredibly useful as well. The training and API guide sections do a good job at explaining more specific things and some sections include code snippets.

The biggest hurdle for me when I started was just setting everything up. Installing Java and Android studio was a pain because all the hiccups. It's more stable and straight forward to install now though. I'm pretty sure the intro chapter in the BNR book covers installation as well.

A very good book and up to date since it was published earlier this year is :Big nerd ranch

Modern Operating Systems by Andrew Tanenbaum is a good book, we used it as the textbook for my OS course in university.

I am currently taking my systems programming class for my CS degree. We use linux, with C and VIM, and have a couple of books that are actually really helpful.
This book will walk you through C and its syntax. I have read through most of it. Its pretty easy to follow and comprehend.

https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628

This book I havent cracked open yet but plan on it today. My teacher swears by it, however.

https://www.amazon.com/Unix-Programming-Environment-Prentice-Hall-Software/dp/013937681X

Self taught professional software engineer here.

Which language you learn is not as important as learning about data structures and complexity analysis. Code organization is also very important.

Pick one high level scripting language (like Python, Ruby, Perl, etc) and one low level systems language (C, C++, Rust, etc) and learn them both inside out.

A couple of books I recommend:

• Code Complete
  
• SICP
  
  As far as practical skills go, you need to learn how to use git (or whatever VC system the companies you are interested in use). You need to learn how to use Unix systems. A great introduction is The UNIX Programming Environment. You need to learn how to read other peoples' code, open source projects are great for that.
  
  When you are getting ready to interview, there is no better resource than Cracking the Coding Interview.

"The Unix Programming Environment"

there lies your problem, Unix is not linux. Also, I'm guessing this is the book you are using? If so, that is from 1983.

this is a great book on Cocoa and OSX programming. The author worked for NeXT (the company that originally created what is now known as Cocoa) and Apple, and now does Cocoa consulting and is generally a well regarded expert. This book is also an enjoyable read to boot.

Do you have any previous programming experience? Are you just looking to learn the core Objective-C language or do you mean the Mac OS X Cocoa framework too?

If you're coming from C++ check out this PDF.

Learn Objective-C on the Mac assumes you know some C and it doesn't really touch on the Cocoa framework, it sticks to the command line. I have found it useful.

Programming in Objective-C 2.0 seems to covers Objective-C and Cocoa and the reviews look good, but I haven't read it.

http://www.amazon.com/Programming-Environment-Addison-Wesley-Professional-Computing/dp/0321637739

Why don't you start reading this?

Should help u a lot with Unix Internals and system calls.

If you wanna go deeper with the hardware, this is the book my university used. It contains a lifetime of knowledge. However, it is nowhere close to the readability of Code. Where I found code to be friendly and inviting, this book is more of a grind through 100 pages in 2 months and question your existence type of thing. For OS stuff, we used this one. I'd say its a lot more friendly to read than the architecture book, but really as you go deeper into both of these subjects, they don't get friendlier.

Read some of this.

This is what I would do in your situation. Pick one of the may University resources for java heres a good one.
Find a secondhand university bookshop and get some used inexpensive comp sci text books that would support such a course. Also I would get a good Linux book and a good comp sic text book for operating systems(difficult but worth while subject). The classic opp systems. To work as a java dev you tend to need to know everything

Here are some resources on operating systems in general, that discuss many of these things:

• You can start from the Wikipedia article on operating system kernels and follow resources from there
  
• For just a basic overview of feature support, Wikipedia has a chart on some kernels. There are various charts comparing other components, like filesystems
  
• The OSDev Wiki has lots of information on operating system development; it is targeted at hobbyists building their own operating systems
  
• Operating Systems Concepts, an undergraduate textbook (Amazon, you can also find pirated PDFs online if you wanted)
  
• The Mach Kernel, a chapter from previous editions of Operating Systems Concepts that has later been removed but is now available for free.
  
• Linux in a Nutshell (somewhat outdated)
  
• The Design and Implementation of the 4.4 BSD Operating System (very outdated, but as you'll see with many of these resources, looking at the design of older versions of kernels can be quite instructive without all of the baggage that tons of hardware support, legacy support, and lots of new and complicated features and concurrency primitives that modern kernels have)
  
• Xv6, an implementation of V6 Unix for modern x86 processors. This is inspired by [John Lion's Commentary on the Sixth Edition UNIX Operating System](Commentary on the Sixth Edition UNIX Operating System), AKA the "Lion's Book"
  
• The Linux Programming Interface has lots of information on the interaction between user-space and the kernel in Linux, and compares many of the interfaces to other systems.
  
• Mac OS X Internals details a lot of the inner workings of Mac OS X and the xnu kernel
  
• The Minix 3 Operating System and book
  
  The list goes on and on. This just barely scratches the surface. There is not, as far as I know, any simple side by side comparisons of all of these components of two different operating systems; there are decades worth of benchmarks, academic papers, practical reviews, and so on, but there's no one single source I can point you to, because it's such a big topic.
  
  That's why I asked you to narrow down your question a bit. Start with that Wikipedia article. Determine what you want to learn more about. You probably want to start with learning about the general structure of operating systems, what they do and what all of the components are, then pick one area and a couple of operating systems and focus on those.

For systems, Operating Systems Concepts. This is a classic book.

Operating System Concepts

Understanding the Linux Kernel, Third Edition Writing my own kernel this semester for a class, this is the course textbook and has been an invaluable reference!

Most books are still made out of paper.

Try these : UTLK
and Linux Programming Interface

http://www.amazon.com/Design-Implementation-FreeBSD-Operating-System/dp/0321968972/ref=sr_1_1?ie=UTF8&qid=1418830375&sr=8-1&keywords=BSD

http://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1418830402&sr=8-1&keywords=kernel

http://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1418830420&sr=8-2&keywords=kernel

http://www.amazon.com/Art-Linux-Kernel-Design-Implementation-ebook/dp/B00L2EBELM/ref=sr_1_3?ie=UTF8&qid=1418830446&sr=8-3&keywords=kernel

http://www.amazon.com/Professional-Kernel-Architecture-Wolfgang-Mauerer/dp/0470343435/ref=sr_1_5?ie=UTF8&qid=1418830461&sr=8-5&keywords=kernel

Understanding the Linux Kernel is the book that they recommend you read throughout the course, and it actually seemed to be really helpful to the people who read it. You could brush up on C and basic data structures since you'll be coding a lot in C; you also use x86 but you'll learn that during the class.

Besides that there's not much you could do since most of the material, if not all of it, will probably be new to you unless you've learned about system software/operating systems before. However, if you want a head start then you could start reading Understanding the Linux Kernel. Good luck, and may the Linux gods be on your side during MP3.

Depends on what you mean by being "paid to code." IMO it would be very difficult to get to a level expected of a professional software engineer in that amount of time. I do honestly believe you'll learn to code, it's just that there is so much more to it. You'll also need to learn algorithms and data strucutres at a bare minimum, as well as things like version control and design patterns.

I do think you can get to a level where you could potentially be some sort of administrator, potentially writing scripts or SQL queries, and work your way up from there.

Things you can do:

• Take a course or two on Coursera
  
• See if you can do a few challenges on project euler.
  
• Hang out on Stack Overflow a lot, especially hang out in the tags of whatever you're learning.
  
• Pick up Head First C# if you're set on .Net, otherwise Head First Java. (People may tell you these books are kinda silly but they're good for self-study IMO).
  

I learned by finding something that I needed. A tool, a small program that automated something that I do all the time. For me, it was a program that would go to and crawl an HTML page that had a summary of earnings for my telecommuting job, at the time.

The UI would then display the amount I had made in the current month/week/day with some other useful stats. I ended up adding a graphing feature to it so I could visualize my earnings.

The point is, find something that you need and/or are interested in and just start. Half the problem is trying to overthink a project and not starting. Try to divide up the various processes into smaller processes and build upon that.

A great book I read that helped me with some basics was Head First: C#.

Linux Kernel Development is what's been recommended to me in the past.

If your willing to buy a book, this is really good: http://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_1?ie=UTF8&qid=1417367345&sr=8-1&keywords=linux+kernel+development

You might be interested in trying gentoo, especially before trying LFS.

Edit: Also, if you'd like to read about the kernel itself you could check out this book, I enjoyed it.

We have a meetup specifically for people learning Python...

The Austin Learn Python Meetup
http://www.meetup.com/austinpython/events/195493322/

We meet once a month, and are working our way through this book: http://www.amazon.com/Python-Essential-Reference-David-Beazley/dp/0672329786/ref=sr_1_1?ie=UTF8&qid=1411752072&sr=8-1&keywords=beazley+python

We started about 18 months ago, but rebooted back to the beginning a little over a month ago.

Work through Python Crash Course: A Hands-On, Project-Based Introduction to Programming if you like project-based learning & having relevant context-based examples, or read through Python Essential Reference if you're comfortable with learning raw concepts & want a solid overhead view of what's available to you.
 
Automate the Boring Stuff with Python is another good project-based option:

• Book
  
  
• Online

ThinkPython

Python Essential Reference

This is a good book: Python Essential Reference.

If you're looking for gift ideas for new programmer my advice is always one of the three things:

• A good keyboard.
  
• A good pair of headphones.
  
• Good coffee and mugs.
  
  Those three things usually go over well with programmer-types.

Python Essential Reference is great. It has a medium level overview of almost all of the standard library, and has some great explanations of decorators, 'with' statements, generators/yields, functional programming, testing, network stuff, etc...

It appears to be this book. Looking at the 2011 version, the above quote shows up in Chapter 8, word for word. Looks like they kept it in newer versions as well (and someone said that it was there in the 2008 version, too).

These books specifically:

http://pages.cs.wisc.edu/~remzi/OSTEP/

https://www.amazon.com.au/Operating-Systems-Concepts-Abraham-Silberschatz/dp/1118063333/ref=sr_1_1?ie=UTF8&qid=1551058787&sr=8-1&keywords=Operating+System+Concepts

​

http://man7.org/tlpi/index.html

​

And most importantly a wasted youth reading far too many online newsgroups, rfc's and troubleshooting technical issues.

​

In that pile-o-stuff there are really two main subjects: architecture and operating systems. I'd pick up recent copies of the dinosaur book and where's waldo. Silbershatz and Tanenbaum are seminal authors on both subjects.

There are numerous resources to learn C. Since I seem to be recommending books, Kernighan and Ritchie's book is pretty much the gold standard.

Good luck.

You learned those from this book? Could you briefly explain them? I would like to learn more.

From gleaming at this content this is not aimed at programming. Try this: http://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=sr_1_1?ie=UTF8&qid=1418343920&sr=8-1&keywords=the+linux+programming+interface

I think this is what you're looking for:
http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200

Awesome book spotted under his desk at 2:45

You can't have it both ways. if you want to know exactly then you have to drill down to the fundamentals which are handled at a low level (C & assembly). If you want to understand the general concepts you'll need to make lateral moves and study CS along with having enough of the tiny details to fill in the gaps with your intuition.

I think what you may like is a book on the linux API. This is between kernelland and userland.

Try this one:

https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200

Before you do that ensure you know enough basic C. Linux kernel uses K&R style. So this might be good enough and your best bet to fasttrack.

https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628

Do keep in mind this is 2K pages worth of reading. This should help to fill in enough of what you don't know you don't know so that you can better use google-fu to get you further.

I've also been learning C# for work, and I don't do well in classes: I learn better from books. So if books are your thing, here's a couple recommendations (all of these are on Safari Books Online, see if your work will shell out for a subscription)

• Essential C# 6.0 for a starter book
  
  
• C# In A Nutshell is a great reference book
  
  
• C# In Depth is the book for understanding C# at an intermediate level

O'Reilly always does a solid job. Any of the recently published Microsoft books on C# / .NET / .NET Core are going to be good too. Though they may be dry, you'll be impressed with what you know how to build once you're through it. Also, going through the online tutorials Microsoft maintains is a good way to start. It'll help you hone in on what you want to focus on learning.

“Why is C# better than Python” is a tough question to answer, but the short answer is that all the features of C# were put there for a reason. And there are MANY features; C# has evolved over the years to support virtually all of the programming paradigms you can imagine, from procedural code to object-oriented to functional to low-level memory/hardware interaction to whatever. It’s dauntingly complex to dig into all of it, but you really only need a relatively shallow subset of those features to be productive, and you’ll only get better as you absorb more of the profile. What you find as you watch other languages like Python evolve is that they’re really playing catch-up, trying to patch in features that C# has had from its inception. Of course, trying to stick static type safety in after the fact is extremely difficult, but you’re seeing a lot of that in both Python and JavaScript. The lifecycle typically goes something like this: new developers get a whiff of the complexity of C# and are put off, then are pleasantly surprised by how easy and “flexible” JavaScript seems, spend years working with it, and then after hitting a wall with the limitations of those languages, they start down the rabbit hole of trying to monkey around with them to try to fix them up to be more like C#.

Just from the outset, static typing is a huge necessity for large software projects. You can’t afford to exist in an environment where every change of a property throws the stability of your codebase into question, with a host of problems that you can’t identify until runtime. Code clarity is, I would argue, the DEFINING feature of a stable, healthy project, and what you find with dynamically-typed languages is that people get to be afraid to refactor for clarity, because the code is brittle and can’t be changed with any reasonable
level of confidence.

Som people try to make assertions like “a good linter is just as powerful as a strongly-typed language”, but that just strikes me as nonsense. It’s only true if you can commit to using the language in a very basic, highly-conventional way, and once you’ve done that, what you’ve REALLY done is abandoned the flexibility that was the hallmark of the loosely-typed language in the first place, AND what you end up with is a very limited subset of the features a true statically-typed language gives you. It’s really tantamount to believing that most static-typing support is superfluous, which it is most definitely is not.

The thing about JavaScript in particular is that it received an enormous boost by being the only game in town. It’s still a pretty crappy language, but it used to be considerably worse; people tolerated it because it was the only game in town. Even then, it had its cadre of language evangelists who assured everybody that the overwhelmingly primitive nature of the language was really a great feature, and maybe in some abstract sense they were correct insofar as it was sufficient to become a building block for better transpiled iterations of it. But largely, as new features were introduced, developers embraced them wholeheartedly, which likely wouldn’t have been the case if there really was a ton of value in the extremely raw nature of early JavaScript.

These are a couple of really excellent resources for C#, which really dig into the design motivations of the language:

https://www.amazon.com/C-Depth-3rd-Jon-Skeet/dp/161729134X
https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

It’s worth noting that they’re both enormous books, and ironically the “Nutshell” book is over a thousand pages! That’s the kind of scope that you’re dealing with to really get into what C# has to offer. But once you do, it can feel awkward to switch between that and less-powerful languages. For that reason, I think every developer in any language could stand to learn about C#, since it’s just a great case study in language design.

All of that said, I always think it’s important to remember that programming in most dynamically-typed languages is pretty much like writing every C# program using Dictionary(string, object) as your only data type.

I'd suggest checking out Brackeys/Sebastion Lague/Sykoo On youtube as well as this website for tons of more in-depth written tutorials, for getting started, there's a ton of resources amongst those references. As far as generic C# stuff, for me the only way to tackle a new language is a good OReilly (or similar) book, I have this book which I believe covers a much newer version of C# than unity uses, but still is incredibly helpful.

Also, this is definitely not such a complex language that anyone should be suggesting taking another path first, yes here are are complex parts to C#, a lot of which I myself have yet to master. But you can do a lot of really cool stuff with simple concepts. I just finished building a physics simulator for my procedural engine and that was using only basic C# skills and built in Unity commands, nothing fancy at all. Don't let complexity scare you away, pick what you want to do, learn how to do that specifically to your satisfaction, rinse wash repeat. Do that for 6 months to a year and you'll be amazed by how much you've learned.

Good luck!

What helped me, way back in the day was the O'Reilly book.


https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650/ref=sr_1_4?ie=UTF8&qid=1539150580&sr=8-4

​

Had to learn C# for work so of course I took tutorials, downloaded some stuff and tinkered around, but I had no idea what I was doing. Started reading the O'Reilly book on my lunch breaks and making up exercise for myself. Took me months, but I learned a ton. Within those few months I already figured out tons of way to save myself time and frustration.


Another good idea is taking the C# Role Track at Pluralsight.


https://www.pluralsight.com/paths/csharp


I'm about halfway through it now, and I've learned quite a bit. I've been a C# dev for years. Really gets into all the nook and crannies of the language.


​

Do start with C and then buy The Linux Programming Interface. Afterwards, I recommend buying a book dedicated to pthreads and another on sockets. Of course, do remember to do the actual exercises.

Don't overlook the included user manual. :help usr_toc will take you there. It is based on the book "Vi IMproved--Vim," which is also available free in PDF format on the Internet because it is published under the Open Publication License. The book is dated, but the manual is up-to-date and tracks with the book very closely.

Derek Wyatt's tutorial videos are good, but there is another vim video tutorial set at Vimcasts.

If you would rather read, but don't want to dig into a five-hundred page book, "A Byte of Vim" may be more manageable. Several of these resources are listed in this subreddit's sidebar.

Several books are now available that cover Vim nicely: "Learning the Vi and Vim Editors," "vi and Vim Editors Pocket Reference," "Hacking Vim 7.2," "Practical Vim: Edit Text at the Speed of Thought," and a brand new book: "Pro Vim," all available on Amazon.

Practical Vim - Edit Text at the Speed of Thought by Drew Neil is the best book I've found for going beyond the beginner stage.

Preview here.

I would recommend:
https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

Fantastic book for pros.

My recommendations are:

1. Watch vimcasts
   
2. Get the Practical Vim book. It really improved my vimming dramatically.
   
3. Map <Esc> to something easier. I use jk (inoremap jk <Esc>) because it's a sequence that you rarely type when programming. If you don't like that, you could use <C-c> (which is a default binding) if you map Caps-lock to CTRL (I recommend doing this regardless, but it needs to be done at the OS level).
   
4. Don't use the arrow keys.

If you must buy a book, start here: https://www.amazon.com/dp/1593272200/

I love Safari. The only book they haven't had that I've wanted is Practical Vim. But, the book is well worth the price.

I'm doing almost no web stuff, but it always feels like a lot of people use vim for html/css/js, so I guess it can be a good fit. Since a compiled language like java/c++ usually requires ide features to use or debug(debugger, auto completion, type hierarchy, go to definition, refactor, etc.), it can be a bit of a ride to configure vim to be up to the task(usually a lot of plugins). Not the same for something like html/css, which is usually debugged/developed through the browser anyways.

Also, when I code in vim, its usually more of a mix of vim and commandline: ctrl+z out to do some grepping/git stuff, fg back to vim, close vim and open in a different directory, etc. Since you said you are working under windows, your workflow will probably differ a lot.

My suggestion would be: See how far you can get with vim. If it feels uncomfortable compared to your usual IDE, try pushing it a little further, and see if you can't find a solution. But, in the end, be honest with yourself: If the IDE feels better and lets you work faster and more comfortable, you have to accept that. Maybe vim is not the right tool for this task, doesn't mean you have to forsake it completely or anything. In case you find yourself in vim-wonderland and every other IDE/Texteditor can't stand up to vim anymore, then thats fine too. Or it might be a combination of the two. But you won't know that until you try. Just go for it and be honest with the result.

Also, as a side note, always remember your employer is the one paying you. So if you are being payed per hour(instead of per-project for example), he or she will probably expect you to work at an acceptable speed, and not for you to spend your time configuring vim, if you could be using something "proven" and mainstream just as well. But that completely depends or your employer. For the same reason, consider buying http://www.amazon.com/Practical-Vim-Thought-Pragmatic-Programmers/dp/1934356980/ if you haven't already. I used to own a copy(until I lost it), and it helped me a lot. Especially if you are already familiar with vim, it has huge potential.

Recapture: just try it out and be honest with the result; remember that your workflow might consist of other tools as well(not just editor/ide); don't waste your employer's money; consider buying practical vim(really!)

Since I don't really do web stuff, I can't say which plugins are really useful, so maybe somebody else will be able to help you out there.

Good luck! ;)

I'm not sure what book you're referring to. I can't seem to find it. If you're referring to this one: http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200 then I couldn't disagree more. That book is packed with TONS of useful information and examples everywhere. I've used a great deal of it. I can only assume you're talking about a different book or you didn't get very far.

What do you REALLY want to do? Because if you want to write systems level applications in C for Linux, you're not going to learn it overnight. It's going to take a lot of reading. You're not going to hop on codecademy, crank out a few tutorials and suddenly be good at it.

What's your background? What experience do you have? And again, what are you trying to accomplish, big picture?

I could be wrong but I read your post as "This book is TL;DR. I want a shortcut." There really aren't any for things like that.

Practical Vim is a fantastic book for boosting your vim-fu, it's written in such a way that you can pick it up and read as little or as much as you like, and still get something out of it. I bought it on the strength of the Amazon reviews after having used Vim for 12 years but never really mastering it, and I now edit a lot quicker than I did before.

This one

The latest edition of this book will be released on August 25, 2017.
https://www.amazon.com/dp/1491987650/_encoding=UTF8?coliid=IFRETBPWLFYRO&colid=11QVEMNY6RZ6

I look up whatever I need in The Linux Programming Interface.
It’s exceptionally well written and covers a broad range of topics.
One of my favorite technical books ever.

Also, just read the manpages for Linux headers and syscalls.
Often they were written by the same author.

I'd make sure I have a really solid understanding of systems and networks, e.g. how Linux works. This book seems like a great overview and I love No Starch Press. There's also this book which is used by Carnegie Mellon's introductory systems course, though that might be a bit too deep to dive into straight away, more like something that could be used if you want a deeper understanding of how systems work. You should have some familiarity with C just as foundational knowledge. The guy who wrote Learn Python The Hard Way also wrote an intro to C, Learn C the Hard Way. He's added a lot more material than the last time I checked (~Dec 2012) which looks like it covers a lot of topics so it would be great to work through it.

Some more technical books on this subject that are well regarded and can be used as reference books are Advanced Programming in the Unix Environment, Unix Network Programming, and The Linux Programming Interface

Also in addition to Python I'd also suggest learning some Ruby (Practical Object-Oriented Design in Ruby and Programming Ruby 1.9 & 2.0 are two resources I'd recommend), it's what Chef is/was implemented in and is fairly nice to work with.

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

If you look for literature: Andrew Tanenbaum has written some books, especially Modern Operating Systems (http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X, but please don't buy it on Amazon, go to your local dealer or library). Tanenbaum's books and operating system Minix were also inspiration and help for Linus Torvalds when starting Linux.

To get back to technology :P

I personally didn't find assembler actually interesting because it's too low-level (you have to do too much work to achieve anything), so I didn't actually learn it (although I am able to roughly understand some disassembled code). My feeling regarding the bashing of C is that many people are afraid of it – because it is too complicated, or too dangerous, or they don't understand pointers or whatever, so they talk negatively about it. C is anything but archaic, it is essential to modern computing. The same with C++: Many people hate it (although many of them don't even know it) because they don't understand its concept: That you may do anything, but that you are responsible for it. The language gives you an amount of power not provided by languages like Python, Java or C#. They reverse this fact and say things like "duh, memory leaks" or "duh, segmentation fault" – just because they were bad programmers at the time they tried C++ and didn't manage to accomplish anything but segmentation faults. C++ is in fact the most complex language currently available, I can't think of another language requiring such a high skill level for safely writing production apps.

Two commonly recommended books on this topic are The Dinosaur Book and Modern Operating Systems. For something a little more concise (and free) you could try Operating Systems: Three Easy Pieces.

For an actual course, you could try Computer System Engineering from MIT Open Courseware.

Modern Operating Systems. the 4th edition was release in March 2014.

http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X

More like CS University curriculum. Such as https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X/

It's worth it to try every approach and make you own decision.

Don't forget to read something like Modern Operating Systems (4th Edition) https://www.amazon.com/dp/013359162X/ref=cm_sw_r_cp_apa_i_HTBVDbGBKG5Q0b to better understand how it actually works.

Tanenbaum's bible will most likely be the course literature for your upcoming operating system class at university. It's a bit pricy, but I'm sure your local library or pirate bay has a copy. Doesn't hurt to dig into it early.

That said, modern computers can be a bit overwhelming. Banging directly on hardware was commonplace for any program back in the C64/Amiga days. If you have any interest in retro computers, these are very well documented by now.

Edit: I guess I was actually thinking of this book

Modern operating systems by Andrew Tanenbaum

I think that system programmers should know how OSs work. Concepts like virtual memory, the call stack and paging may be the answer to your question about when to consider something to be big

I haven't gotten far into app development, It's been on my todo list for a while. But I've been planning on going through this youtube playlist (might be a bit old by now, not sure if there is anything more recent thats better) and I recently got the Big Nerd Ranch book for android development.  

Are you going to continue with your major in Computer Science at UNR, I've recently transferred there from Truckee Meadows Community College, and I feel like the courses required for it should be a good enough understanding to pick up app development easily.
 

edit: changed big nerd ranch link to 3rd edition

I knew more than enough Java to understand everything in the Big Nerd Ranch book, which is how I started learning Android. I probably couldn't just code anything I could think up (still can't), but having a good Java foundation makes it so much easier to understand all the Android docs and guides.

This book:

https://www.amazon.com/Android-Programming-Ranch-Guide-Guides/dp/0134706056/ref=sr_1_1?ie=UTF8&qid=1523533063&sr=8-1&keywords=big+nerd+ranch+android+programming

Android uses Java, which is an extremely versatile modern programming language. So it’s not at all a bad first language to learn. It’s also high-level enough to where it doesn’t use pointers which confuses some beginners.

I would check this book out: Android Programming: The Big Nerd Ranch Guide (3rd Edition) (Big Nerd Ranch Guides) https://www.amazon.com/dp/0134706056/

>ed? Well, there's no "right amount" IMO. If you want to go Java path, I recommend this book Android Programming: The Big Nerd Ranch Guide (
>
>https://www.amazon.com/Android-Programming-Ranch-Guide-Guides/dp/0134706056/ref=sr_1_2?ie=UTF8&qid=1551068980&sr=8-2
>
>). I

I'm glad that I read this comment.

You will need one or more, or some combination of these. Don't like the plethora of choices give you analysis paralysis, just pick one and stick with it for a while.

Videos/courses

1. Android basics by Udacity -> graduate to Android Nanodegree
   
2. Lynda Android path. You can access lydna for free with a library card.
   
   Course
   
   
3. Recently updated (9/18) Android code labs + slides by Google
   
   Books
   
   
4. Commons ware online book
   
5. Professional Android
   
6. Big Nerd Ranch

My ultimate goal at the moment is to move into a digital nomad type role doing mobile development, preferably for Android.

So, my invisioned path from here is to buy or download some books on Android development and start learning. I've located what seems like a good source (of sources) for learning about Java/Android here, (taken from here)though I don't know because I haven't the links yet.

What is a good (and free) Java / Android Development courses online? Anyone have an opinion on Google's?

Does this path seem good? Should I be considering Java and Android Development the same thing? Thank you!

Not sure if it's for Linux or OS in general. The other links here are a nice look at Linux in general. These are the two textbooks used in most modern OS classes:

• The Circus Book - Modern Operating Systems
  
• The Dinosaur Book - Operating System Concepts
  
  Honestly, I find the first much easier to read. The second discusses things at a verbose and somewhat rambling fashion. They're both good for learning the real ideas behind modern operating systems, though.

First, you need to learn C and be very comfortable with it -- this happens when you work on a large project with multiple source files, especially when you start one from scratch yourself.

Second, you need to learn about operating system/kernel fundamentals -- C is just a tool/language. You need to know a lot about what you're developing! So get a book on OS -- http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639 or http://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720 , or reading lecture notes from your school (preferrably from a very good Computer Science school). Here's one: http://www.student.cs.uwaterloo.ca/~cs350/W11/reading.html

Third, start exploring the kernel source code and try and figure what things are and how things work. Subscribe to linux mailing lists, read more articles on how Linux internals work, etc.

The most important step here is step number 2! It will require the most work and the most effort.

It'll be challenging and fun, and will take quite a lot of time :) Be persistant and good luck!

I always buy my textbooks in India (get someone to ship it). I have spent a total of $60 in the last 2 years on text books. Yes, some textbooks that are ~$150here are the equivalent of ~$8 there.

Here: http://www.amazon.ca/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639 - $156

India: http://www.sapnaonline.com/index.php?option=com_books&view=product&productID=EBK0006776&product=MODERN-OPERATING-SYSTEMS - 360Rs = $8

Excellent book!

You can't forget Tanenbaum: http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639/ref=sr_1_1?s=books&ie=UTF8&qid=1302667905&sr=1-1

Or the design of the BSD operating system: http://www.amazon.com/Design-Implementation-FreeBSD-Operating-System/dp/0201702452/ref=sr_1_2?s=books&ie=UTF8&qid=1302667950&sr=1-2

Two Must-haves for any *nix // C guys out there!

Modern Operating Systems (3rd Edition)

Nah, http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639.

The famous Tanenbaum circus, for those who haven't seen it:

http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639

Hi,

To design and program a (very) tiny operating system, I would recommand you to learn C in an Unix environnement. C has absolutly no automated memory management and is a pre-requisite to OS programming and in particular in kernel programming. User level could be developped in any almost any language but that's another discussion.

But above all, you need to understand what is an operating system and how it is architectured in its common forms. There are several basic architectures you must know and undestand deeply. But if you cannot say the difference between a kernel and an operating system, you should first give a read to this book. Unlike many other famous computer science books, this one is an absolute must read (haters gonna hate).

If you're already familiar with basics, a good first step might be to write a dummy kernel module for your favorite Unix. You will discover a less known part of your OS api and with the help of man pages, you will be eventually able to write a "cat" or "echo" driver. From here, well, the limit is your imagination. After that (at least a year from today ;) ), you could start to design and implement the first lines of an "OrlandoFuriosoOS", but it's a long and bitchy road :D.

Most advanced processors have a memory management unit (an MMU). It's a hardware mechanism for limiting the access a program has to memory (be it RAM, or memory-mapped hardware like graphics cards)

It has at least two modes: a "kernel mode" accessed only by the OS, in which the entirety of memory is available; and a "user mode", accessed by regular programs, in which only data that belongs to this program is accessible. While running in user mode, the program won't be able to read data of another program, or anything like that. This is called virtual memory and is essential for providing security (otherwise, programs might be able to read data from other programs).

Periodically, the processor will interrupt the program that is running and pass the control back to the operating system. This is called [preemptive multitasking](http://en.wikipedia.org/wiki/Preemption_(computing). The OS can then pass control to some other program. The goal here is to give each program a fair share of processor time. This is accomplished by the process scheduler.

[ Scheduling was a somewhat heated area on Linux some years ago, where Con Kolivas, an amateur kernel hacker, proposed schedulers (the rotating staircase deadline scheduler and later the brain fuck scheduler) that would improve interactivity, but his code was rejected and he left (but eventually a code with similar goals was incorporated in Linux) ]

External events, like pressing the keyboard, moving the mouse, or receiving data from internet will interrupt the running program too, and pass control to the OS. Ever wondered why you can do ctrl+alt+del (or something like Alt+SysRQ+B in Linux) even if the computer seems to have hanged? While the graphical interface might be frozen, keyboard input is delivered by interrupts, and so if the processor is running it's always delivered. (sometimes the kernel is running out of memory or is having some other problem and has a hard time fulfilling user input - but it always gets delivered)

Also, the OS shouldn't be doing a lot of work inside the interrupt. What if another interrupt fires while he is at it? To prevent that, it disables interrupts. Non-urgent bookkeeping code competes for processor time just like regular programs, and have to go through the scheduler.

Anyway, what if a program wants to read a file, or send data to Internet? It must call a system call. It passes control to the operating system, which can do a lot of things. Sometimes, the program asked something that will take a while - for example, asked to read a file, which can take some milliseconds on a hard disk - and the kernel puts it to sleep. In the mean time it can then schedule other programs, and will wake the program when its data arrives.

The other major thing that is missing are drivers. Processors can communicate with the external world by means of pins that carry electrical signals. Those pins are typically connected to a bus like PCI express, which in turn ultimately connects everything to the processor - keyboard, mouse, graphics card, sound card, etc. While the processor handles the low-level aspects of the bus (and the BIOS does some device initialization), it's the kernel that is in charge of actually receiving and sending data to each of those devices. It's sometimes done by using memory-mapping (so the kernel writes and reads from some pre-determined part of memory to communicate to a device), but there are other methods. Each device has its own way to talk with the processor, and the kernel has to learn it all. Because, what use would have a kernel if you couldn't display anything on a monitor and couldn't type with a keyboard?

I didn't touch everything about operating systems, but anyway, interrupts and syscalls bring operating systems to live, drivers makes operating systems useful, and MMUs makes it much easier to write secure operating systems. While you can run Linux without a MMU, for such processors it's more common to write your code without an operating system (those processors are typically called microcontrollers and are used in embedded environments, like a children's toy or controlling an industrial plant - often you don't need a full blown operating system!)

Anyway, notice that I used "operating system" and "kernel" interchangeable here. That's because in computer science terms, they are the same (and when you study operating systems at university, you normally are studying kernels. For example Modern Operating Systems, a classic book on the field, is about kernels). Also, where I said "processor" you could say "CPU".

Another thing: there is also the idea that current kernels are too bloated, and we should move code from the kernel to user programs (what's left is a minimal kernel called microkernel). For example, you could write device drivers and filesystems as regular programs, instead of having them in the kernel. That way, if they crash, they won't bring the whole system down (the blue screen of death of Windows fame happened mostly due to crappy device drivers). The opposite of microkernel is monolithic kernel. The trouble with microkernels is that they are slower, sometimes considerably so.

It's not online and you have to *gasp* pay for it, but I've found the classic book UNIX Programming Environment to still be one of the best introductions to UNIX and C programming. It is also a great introduction to the UNIX mindset.

The Unix Programming Environment

> The marketing of Plan9 for the biggest part consist of snobish comments like yours, so i conclude you don't want more users. The Lisp guys are more open than you.

On this you are quite right, but then the Plan 9 user base very heterogeneous, in the end most people just don't care about marketing, they are happy to sit in a corner and do their thing and don't care much if the rest of the world jump from a cliff.

> Plan9 doesn't provide anything to non-programmers, they wouldn't get from UNIX and some things are better in UNIX.
Don't underestimate the intelligence of non-programmers, I know biologists, medicine students and even a law student that use Plan 9. I think the wonderful thing about the original Unix philosophy, and that is taken even further by Plan 9 is to allow people that are not programmers to use some really simple but also powerful tools to do their job. Of course it requires a bit more initiative and creativity, but at the same time you are much more free to take advantage of the system for tasks that it was not designed for.

The Unix Programming Environment is a book I think ever computer user should read, because it shows how everyone can easily learn to program their software environment... if that environment is built properly.

> For example Plan9 was praised for the beautiful fonts, when they invented utf8, but Apple surpassed them long ago.

I don't see what you mean by "surpassed", last I checked OS X still has trouble dealing with UTF-8 properly(I wont argue the details because I'm not a OS X user, I only report what I heard), as do every other Unix system I have ever tried. The Plan 9 UTF-8 code was written in 92', and has barely changed since, because it just works!

Anyway, the most important thing about Plan 9 is not just the code(which is worth admiring and studying by anyone interested in writing top quality software) and the innovative ideas(which are worth copying), but the philosophy, which is not too different from the original Unix philosophy... which unfortunately everyone forgot long ago. Programming is the art of managing complexity, and you don't fight complexity by adding extra complexity, you fight it with simplicity and clarity.

The cheapest, fastest, and most reliable components are those that aren't there. -- Gordon Bell

Install ubuntu. Then read this, the same than anyone else for the last 3 or 4 decades:

https://www.amazon.es/UNIX-Programming-Environment-Prentice-Hall-Software/dp/013937681X

Or,

• The UNIX Programming Environment,
  
• Software Tools, and
  
• The Elements of Programming Style
  
  for 877 pages. (WTF? UPE and ST are ~350 pages? I don't remember them being that long.)

I have to say - Videos can't get into as much depth as books - they may feel more comfortable, but you're not learning as much.

That said, if you can tolerate books, start with a classic: The Unix Programming Environment. The coverage of system calls, in particular, will connect your userland knowledge with OS operations.

Oh wait, it's available online!


And Unix Systems Architecture is another classic that would be a great next step, but doesn't seem to be available online as a PDF ...

Well, there is The UNIX Programming Environment by Kernighan and Pike (K&P). It's a little dated but it covers sh and awk, including the use of grep, sed, lex, yacc, and the like. You might want to combine it with a more modern book to learn the latest enhancements to bash.

i'd like to hear a comparison of this to Steven's http://www.amazon.com/Programming-Environment-Addison-Wesley-Professional-Computing/dp/0201433079 (2nd edition includes Linux) since that book is acknowledged to be a masterpiece.

I've got started on iOS programming 3.5 years ago reading the Kochan Objective-C book (probably the 3rd edition).

I am (was) an experienced programmer and found Kochan very helpful, specially on the memory management side of it. Learning C came after that, when I needed to do something that required more performance on iOS.

I also read part of Hillegass Cocoa book because I had it at hand, which got me a good starting point to learn Cocoa Touch online.

For iOS devices, you're going to want to start here, this will get you familiarized with the NeXtStep family of jive turkeys, followed up with a more formal introduction to Objective-C. I'll be honest, having some working knowledge of C will never hurt you, so after you're done with that, take a peek at K&R.

If you're aiming for Android, you have a bit of a different education outlook, I'd recommend brushing up with Head First Java. When I started poking around with Android, I read Hello, Android most of it should be still pretty relevant. I'm not entirely sure if it has been updated as of late, I outgrew it rather quickly, and if you do too; pretty much anything and everything by Mark Murphy is relevant. Best of luck!

This is the cocoa book I have.

Looks like there's not only a kindle edition but a newer one as well.

Best of luck!

Take the beaten path. One of the niceties of developing for an established commercial operating system is having a central and authoritative source for documentation, rather than having to comb the web for fragments of information. There are certainly decent books available, but developer.apple.com has everything you need.

Begin at the Mac OS X Reference Library. You seem anxious to dive in, so the Cocoa Application Tutorial, available from the "getting started" section of the reference library, will be an ideal first stop.

If you can wait, go along with rattboi's mention of Hillegass's book (it's great!), and get Programming in Objective-C 2.0 (2nd Edition) (Developer's Library) (Paperback) if you can wait a few months.

Well I replied while I was on my phone so I couldn't link it. I followed my directions and was able to find it. It is the first book when you search for Objective C 2.0. It's called Programming in Objective C 2.0 and it's written by Stephan Kochan. Here's the link

Programming in Objective-C is a good explanation of the Objective-C language. It shouldn't be hard to pick up if you're familiar with C. Beginning iPhone 3 Development assumes you have Objective-C knowledge and jumps right into iPhone development explaining how to use XCode as you go.

As others have mentioned, trying to use Vim as an IDE is thinking about the problem or Vim in an inverse manner that will lead to frustration. The Acme Text Editor's model for composing tools to form an IDE is exactly how one uses Vim most effectively.

A concrete Vim specific example is programming Go in Vim: VimGo. Note how in the context of Go instead of subsuming the functionality of external tools, the external tools are instead leveraged and exposed through an interface or accessed through existing Vim functionality.

That is exactly how to wield Vim and external tools masterfully and with the most efficacy. The Unix as an IDE articles discuss this concept in depth also and are excellent. Separation of concerns is precisely how all tools should be designed, something which Plan 9 and Inferno OS display masterfully and irrefutably; note how well done, completely encapsulated abstractions enable a completely composable environment as a result, brilliant no?

That same pursuit is realized through the Go toolchain, much of Haskell, and increasingly through the Clang toolchain, which is very powerful and very freeing to create great, completely optimized workflows.

If you really want to grok the mindset and approach to wielding external tools effectively and why tools must be designed this way for maximum workflow efficacy, I highly recommend reading and understanding the literature written by Brian Stuart's Principles of Operating Systems: Design and Applications that covers Inferno OS's design very well, and W. Richard Stevens' Advanced Programming in the UNIX Environment, the latter of which is a classic CS text and very lucid. Cat-V has a lot of great articles which discuss various tools as well.

The workflows enabled through the UNIX Philosophy is so much more effecient that even when outside a UNIX environment I utilize the tools through a VM rather than being hamstrung in an environment which eschews that design completely.

And because these tools are ubiquitous I can avoid relearning how to accomplish the same thing over and over as a result, meaning that the initial opportunity cost is worthwhile in the long run. Linux is increasingly incorporating features in the kernel which improve upon previous implementations as well as in user space, so it is an exciting time for system programmers as well as other programmers.

In that case...
You may want to wait for the 5th edition of UNIX and Linux System Administration, as it should release near the end of this year and they don't release new versions that often.

A good way to get started building a college library is to see what the curriculum for the school is and what books are required by professors. Often other colleges will list their book recommendations for the courses online to get an idea of where to start looking. (I know my school has an online bookstore that lists the books for each course and is open to the public)

At least one or two good books in each of those categories, to get a rough idea to start:

• General Programming (A book for each core language, though a lot of information is online as well)
  C, C++, Java, Python and Ruby are popular to start with
  
  
• Web Development (a wide area, but an html/css/javascript text is basic)
  
  
• System Programming (Windows and Linux are wildly different, should probably have both even if not taught - though you already have one linux system programming text recommended, 'the linux programming interface')
  https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739
  https://www.amazon.com/Programming-Paperback-Addison-Wesley-Microsoft-Technology/dp/0134382250
  
  
• Computer Networking
  you already have a couple here
  
  
• Algorithms - the selected book (Introduction to Algorithms) is good, sometimes used for two courses, a complementary text wouldn't hurt too
  
  
• Artificial Intelligence
  https://www.amazon.com/Artificial-Intelligence-Modern-Approach-3rd/dp/0136042597
  
  
• Numerical Methods
  
  
• System Administration (Windows and Linux are different, the recommended text is good for Linux - here's a windows one)
  https://www.amazon.com/Windows-Internals-Part-architecture-management/dp/0735684189 (coming soon)
  
  
• Parallel Computing
  
  
• Distributed Computing
  
  
• Operating Systems - I personally like Stallings' text, though Tanenbaum and Silberschatz is popular too
  
  
• Databases - Nearly all the database books are not that good, in my opinion, but still should have something
  
  
• Cryptography
  
  
• Computer Security
  
  Edit: On second thought, pretty much every college teaches system programming on linux - so perhaps just the linux texts would be adequate for that.

Not to dismiss the other book suggestions because they are also good but one of the most important, relevant, useful and famous books of all time about UNIX internal stuff is "Advanced Programming in the UNIX Environment" by Richard Stevens -- Amazon Link


It's not for the faint of heart and you'll need solid understanding of C-based languages... it's as gory as it can get. :)

Self-directed teaching has its limitations. For example, misreading or misunderstanding the system documentation. Debugging would have been less useful here because the program blows up after you make a system call -- a typical indication of programmer error. One tool you can use in such a situation is more documentation, especially one with additional examples and discussion. Take a look at Advanced Programming UNIX Environment, 3rd edition to get more information on system programming. It helps you build up a foundation and serves as a solid reference.

"Operating Systems" and "Software Tools and Systems Programming" were the most helpful to me. Both were difficult with difficult profs, but very interesting so I got a lot out of it. The Stevens' book was the text for "Software Tools" and all his books are very good.

The best book I've run into on this front is http://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739/ref=sr_1_1?s=books&ie=UTF8&qid=1453687799&sr=1-1&keywords=advanced+programming+in+the+unix+environment

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.

I just started learning it for my class in University. I am surprised at how much I like it and how much deeper my understanding of Linux has got. It might be annoying at first but trust me, you learn a lot. You should also give Advanced Programming in the UNIX Environment a read. It has taught me so many things already!

Tools like this show you what the system is doing for the application. If you don't know what applications want to do, the output is going to be hard to understand. Perhaps work on some UNIX programming to see what UNIX looks like from an app's point of view?

http://www.amazon.com/gp/product/0321637739

Per i sistemi operativi https://www.amazon.it/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720

Per le reti https://www.amazon.it/calcolatori-internet-approccio-top-down-aggiornamento/dp/8871929381


Per iniziare forse sono un po' troppo (anche come prezzo, il primo sono €80) però secondo me sono i migliori.

I am pretty poor at these topics as well, but I remember using this book in my college course on operating systems. If you can get your hands on a copy I'm sure it would be a good resource.

There are many heuristic algorithms to find a suitable position for the file. Also, note that it is quite likely that you will not be able to find a place that is large enough to fit your file. That's why operating systems store files in blocks or clusters. Different file systems have different approaches for file allocation and minimizing disk fragmentation. Therefore, it is safe to say that there is no ideal solution for these problems and it varies from one file system to another. You can read wikipedia article about fragmentation {Seriously? I cannot have a link with ')' ?!}. Or if you are more interested than that go ahead and read about file systems. If you want to learn this stuff completely I absolutely love this book.

Duntemann's book uses Linux and flat address space in the third edition.

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

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

No, they are not. For example, semaphores are often not kernel objects. And in any case, the kernel is written in a programming language. Anyway, I've always found https://www.amazon.co.uk/Understanding-Linux-Kernel-Daniel-Plerre/dp/0596005652 to be a good introduction to OS programming in general. In C.

It's really very easy. I've only written one linux driver for a new hardware serial port and a few other kernel modules and have written a couple dozen drivers for other operating systems.

This is my favourite linux book although I'm sure that have others, it's the only one I can name off the top of my head.

I would start off by adding a new API. That was my favourite exercize and only required a few lines of code.

edit: An Important thing to be able to do is to control the hardware without an OS. When you can do that, squeezing it into whatever is usually a simple task. Arduino is a nice learning platform for hardware.

The best one for general OS design & implementation:

http://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388/ref=sr_1_1?s=books&ie=UTF8&qid=1411043393&sr=1-1&keywords=operating+system+design+and+implementation

Linux-specific:

http://www.amazon.com/Understanding-Linux-Kernel-Third-Edition/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1411043351&sr=8-1&keywords=understanding+the+linux+kernel

http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468/ref=pd_bxgy_b_text_z

Three esxi servers, each with more than one NIC, and one separate vcenter server is a great starting point. This allows you to tune DRS, HA, and even fault tolerance. Once you get that down, you'll want to be able to tune VMs properly to run most effectively in a virtual environment.

I enjoyed reading these books, though some are "dated" now, the contents are still very relevant. They won't get you anywhere in particular by themselves, but when you combine them with the self-teaching nature of sysadmins I've previously described, these will generously add to your toolset.

HA and DRS deepdive
Sed & Awk

Mastering Regular Expressions. I use rubular.com often.

Pro Puppet

Anything by Bruce Schneier is usually worth your time.

Though I no longer administer a large number of Windows machines, I am a huge fan of Mark Minasi. The Server 2003 book was super helpful in building and maintaining Windows Domains.

I have an old edition of the DNS and Bind book kicking around somewhere.

Understanding the Linux Kernel has largely been useful to me when doing anything "close to the kernel". Not a good beginner's book.

I've never used an apache book, but I enjoyed the Varnish book. This definitely helped me.

Of course, these books don't cover everything, and those listed are relevant to my interests so your mileage may vary. You'll never go wrong teaching yourself new skills though!

EDIT: I forgot about the latest book I've read. I used tmux for a little over a year before purchasing a book on it, and it has improved my use of the program.

I didn't know this. I figured some portion would be applicable but probably not a ton or even most. I grabbed head first C# for a different reason and ended up not needing it and am now hopeful that it wasn't money wasted even if it doesn't directly have to do with Unity.

http://www.amazon.com/Head-First-C-Andrew-Stellman/dp/0596514824

The head first books tend to be pretty good for people who haven't done development before. Unfortunately I don't know of anything unity specific.

This sounds like a good option for you:

http://www.amazon.com/Head-First-C-Andrew-Stellman/dp/0596514824

I'm not /u/MinecraftHardon, but you could try the Microsoft Virtual Academy. If you want text, Head First C# is recommended by quite a few people.

http://www.dotnetperls.com/ is a great website for reference. Reading through that will give you a lot of the basics on how things are done in .Net land. That's more a reference than tutorial, though. I'd take a look at Head First C#. Its reasonably comprehensive, and very accessible (to the point where some complain about its style not being serious enough) -- imo its the best all-around intro to C# you'll find.

Head first c#, and then Pro C#

Hey norelevantcomments, my husband is a computer programmer and he shares the dream. He always recommends the "Head Start" books for those interested in that field, and here is a link for the C# one:http://www.amazon.com/Head-First-C-Andrew-Stellman/dp/0596514824.

If you enjoy projects and quizze method of learning then the best series I can suggest is Head First Series. they have books in all manner of coding and their C# & [Design Pattern]() books are great for beginners to intermediates. I extremly recommend the Design Pattern one.

The biggest difference with this book series is they focus on a Conversational Tone instead of text book talk. And yes while these are more programming related, everything is easily translated to Unity.

Towards the original question. What else would you spend the $10 on? If you really want to learn Unity through video tutorials like theirs then quit fast food for a week, or coffee, or something to make up for the $10.

Ugh...afraid I am not that much of a help there...too old ;) Lots of this actually comes from DOS (you know, the OS of microsoft before windows) programming books and books about the linux kernel in version 2.0 ;) So really old and probably not available anymore. And both had nothing to do with virtualization...just, well DOS was no multitasking system. Direct hardware access and even manipulating the memory mapping registers were common back then for normal programs (as only one program could run at a time...you could do whatever you wanted, nothing else could get in your way). All this is pretty useless knowledge nowadays...but it helped a lot to know the basics to somewhat understand "modern" stuff like virtualization...it's more just learning how it was done as the basics are still in large parts the same.

But afraid that means I have no clue about a modern book that would teach these topics nicely. (not to mention that my first books about that hardware stuff were still in German...only two years learning English at school were not enough back then to understand English programming books ;))

I heard some good about Linux kernel development but afraid didn't read it...so take with a grain of salt (And this is really more if you are interested how the kernel does things and how hardware access is really done, it's not a book that will help you much with "ordinary" daily work on a linux system.

Afraid I am not aware of any general purpose book for linux at all...there must be some for sure but afraid I always just looked into kind of specialized books...so can't help there at all.

A slightly higher level book that helped me a lot to deal with linux was linux application development (although I read it in the first edition..and german translation back then. In this case I have no excuse for that...by that time I should have been good enough in English to read the original..so probably just some teenager laziness). But this one is really good, leads you through the whole process of writing your own shell...requires basic C knowledge though.

What brings up something interesting...even if not linux related directly...any book about learning the basics of C will also help a lot with linux. I see that a bit different than learning a language like python for example..while learning python will of course also help you understanding linux better in some cases learning C gets you really dirty. It forces you to learn some basics about hardware...most other languages "shield" you there (exception c++ which is also very lowlevel and if you ask me the more interesting language to learn...but if you ask Torvalds he probably would have some strong words of disagreement there. So for the linux kernel learning C is better)

But overall...really better make a new question about this and ask a wider audience...afraid I am just the wrong person to give any good suggestions there.

While I would be really surprised if you found any resources implementing software RAID 5 in C++, you could look at the mdadm C code (used by Linux) to create software RAID:
https://github.com/neilbrown/mdadm

That's written in C, but it's something. If you're doing this simply for learning, I would shoot for something significantly simpler and draw out one source array with three destination arrays (to simulate three drives - you may expand this to N drives later). Then you'll want to work on iterating through the array and calculating/round-robin distributing the parity blocks across the destination arrays. If you want to expand this further and implement it as a driver, that will likely involve you reading a couple books on the relevant OS first. For Linux, I regularly recommend Robert Love's Linux Kernel Development book:
https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468

He does a decent job providing a pretty high-level view of each component of the kernel (considering the complexity of the kernel, 440 pages is short). I also found it to be a really interesting/fun read.

I'm a little short on time to actually read the mdadm code, but I'll check again tomorrow if the above isn't enough to start you off.

The OS is just a program like any other program. In order to really start understanding how it works, you should learn C.

Once you've got some C down, read Advanced Linux Programming

From there read Robert Loves Linux Kernel Development - even if you're not a kernel developer, it'll give you tremendous insight into how the kernel works.

Also check out Linux Device Drivers. I found this & Loves book complemented each other nicely.

You got downvoted because what you said wasn't clear. There is a version of what you said that might be sort of correct, but what you typed really isn't.

Threads and processes are more similar on Linux than they are on other systems because they're both just tasks. See this answer on StackOverflow for an overview. They're both struct task_struct in the C source, which is a huge structure, closing in on 2KB. See this answer on StackOverflow for an overview.

If you're interested in these kinds of things, read e.g. Robert Love's Linux Kernel Development.

Well yes. It has a lot of features, and it was O(1). The scheduler has to be able to support nicety, among other things that I can't think of at the moment. For a good introduction, see this book by Robert Love. I used the second edition. The third edition talks about the newer, O(log n) scheduler. The O(1) scheduler performs better for servers with many tasks and little user interaction, whereas the newer one is apparently much better at minimizing latency for applications with a lot of user interaction, as a desktop would have.

Granted, a round-robin scheduler is O(1), and certainly much faster than the O(1) linux scheduler, but it lacks all sorts of important behavior.

If you're looking for an intro to programming in Python I would suggest Introduction to Computation and Programming Using Python For a general language reference Python Essential Refernce For an introduciton to the included modules The Python Standard Library by example which includes a lot of simple code examples. The book Core Python Application Programming is a great subset of the above books with less over all coverage but greater detail in the example code. And last but not least, for advanced algorithm info Annotated Algorithms in Python

>Is there any books you would recommend as a reference not a guide? I have a few bookmarks that have really helped but i'd love a hard copy on hand.

I personally cut my teeth on a borrowed copy of Python Essential Reference - it's basically just a rehash of the standard library (though it's fantastic to have a hard copy, and it sounds like what you want). You can also try this book by Alex Martelli - I have never read it, but Alex Martelli is practically a god in the Python world (as someone who read GoF's Design Patterns, I loved his Python design patterns talk). Reddit also raves about Learn Python The Hard Way, though I have never read it because I erm... "disagree" with how Zed Shaw tends to approach things (to put it mildly), and I think it's a guide as opposed to a reference.

>Oh, and i've been having difficulty using the built in help function and such, is there a guide on how to use it effectively? I seem to struggle finding examples of the code too and how to use the functions and what i believe are called attributes ( the sub functions, e.g. datetime.datetime()),

I assume that the inbuild help you're talking about is the code documentation? This documentation is intentionally brief, so it's not particularly useful as anything but a reminder. You can create your own simply creating a string after you open a function or class;

def foo(etc):
""" This is the documentation for foo().

Triple quoted so that it can safely run over multiple lines"""

blah

As for the terminology; you are correct that they're called attributes. There are two sorts of attributes - methods (functions) and properties (values). It can get very messy/fun when you use the @property decorator or toy with __getattr__/__getattribute__/__setattr__, but let's not go there (let's just say that Python can be no-holds-barred).

>but i came from PHP where the PHP manual is amazing for a novice/new coder.

Python's online docs are absolutely fantastic. They are a comprehensive reference of not only the builtins and standard library, but also the object model, features, a rather good tutorial, the C API reference, and even heavy stuff like metaprogramming. The only things it's really missing is the really hardcore stuff like __code__ and __mro__, and to be honest, that's probably a good thing.

>And what is the difference between import datetime and from datetime inport datetime. Does it just allow me to call the attribute as datetime() and not datetime.datetime()?

That's exactly correct.

Just to add another complication, you can also from datetime import datetime as tell_me_the_time_please, and then instead of datetime() you can use tell_me_the_time_please(). The reason this is useful is that sometimes things in modules are named too generically (maybe it's main() or something), so you can import part of the module as a different name.

If you like paper books get a copy of Python Essential Reference. After a brief introduction to python it goes through very many standard library modules plus example code. Just the thing for when you need to know how the mumble module works. I've owned every edition from the 2nd and I'm waiting for the 5th edition. If you want an e-book edition be very careful about the formatting of code samples in the e-book. Kindle books are known for major problems with computer code formatting.

An online resource others have mentioned is Python Module of the Week, one of my favourite online resources. The e-book version of this on Amazon is one particularly bad example of code formatting.

I can strongly recommend Python Essential Reference (4th Edition). It covers both Python 2 and 3. Maybe it's not free, but i think it reads much better than the free books from the sidebar.
The only downside of the book is that it is not written for absolut programming beginners, you need to have programming experience in any other language.

This (Python Essential Reference by David Beazley) is easily my #1 Python book for just about everything.

I wish it had a few cheatsheets or some quick references, but aside from that, it covers the language pretty thoroughly.

I started working on my own operating system a few months back (in NIM, not Rust) and can tell you, yes, you're indeed in over you head, but don't let that stop you. Just be aware that progress will be slow and hard. You will have to learn a lot of arcane things about your language, your processor and operating systems in general, while your OS for the most part just crashes and you pour over memory dumps.

I'm not saying this to discourage you, just be aware what you're getting yourself into here. As others have pointed out, there are a bunch of tutorials out there on how to get started with Rust, but that will only get you to the point where you can start your work in earnest.

By far the most useful resource on my adventures so far has been the OSDev Wiki. It's not the best organized place out there, but they have accumulated a lot of knowledge there that can be hard to get your hands on. I can also recommend the "Dinosaur Book" Operating System Concepts for a general overview of stuff operating systems tend to do.

I can tell you that you'll learn a lot, but if you just want to get a taste of systems programming you can also get an Arduino or something and build cool robots - it will take you less time to get into any you'll have more to show for it.

This book is really good. Edit: Seems like I took this for the wrong book. I meant this one

Many people may disagree with me, but as a Linux user on the younger side of the spectrum, I have to say there was one thing that really worked for me to finally switch for good- books.

There's tons of wikis and forums and of course Reddit to ask questions, but it is hard to get good answers. You may end up paying for books (unless you look on the internet for books) but it doesn't beat having a hard copy in front of you. It boils down to a time vs money trade off. The only wiki I would follow is one directly from the developers that act as documentation, not a community wiki. Also worth nothing certain wikis are more tied to linux and the kernel than others, meaning some are comparable/interchangable with the distro you may be using. Still, a novice would not easily put this together.

Forums are also useless unless you have the configuration mentioned in the post or that forum curates tutorials from a specific build they showcase and you as a user decided to build your system to their specifications. There's way too many variables trying to follow online guides, some of which may be out of date.

This i've realized is very true with things like Iommu grouping and PCI Passthrough for kernel based virtual machines. At that point you start modifying in your root directory, things like your kernel booting parameters and what drivers or hardware you're gonna bind or unbind from your system. While that does boil down to having the right hardware, you have to know what you're digging into your kernel for if you dont follow a guide with the same exact parts that are being passthrough or the cpus or chipsets are different.

Books are especially handy when you have a borked system, like you're in a bash prompt or an initramfs prompt or grub and need to get into a bootable part of the system. Linux takes practice. Sometimes its easier to page through a book than to search through forums.

Another thing about being an intermediate or expert Linux user is that you don't care much about distros or what other users or communities do. It wont matter as under the hood it's all the same, spare the desktop and the package managers. Once you're out of that mentality you just care about getting whatever you want done. I'm not one of those guys that's super gung-ho FOSS and open source. I just use what gets the job done. Also from a security perspective, yes Linux is in theory MORE secure but anything can be hardened or left vulnerable. It's more configuration tied than many uses and forums or threads lead it on to be.

My workload involves talking to servers and quite a bit of programming and scripting, in a variety of capacities. That's what led me to linux over the competitors, but I'm not so prudent to never ever want to use the competitor again or have a computer with it. With understanding Linux more, I use it more as a tool than to be part of the philosophy or community, though that enthusiasm pushes for new developments in the kernel.

I'm assuming you're a novice but comfortable enough in linux to get through certain things:

In any computer related thing, always TEST a deployment or feature first- From your linux system, use KVM or Virtualbox/vmware to spin up a few linux VMs, could even be a copy of your current image. This way any tweaks or things you want to test or try out is in an environment you can start over in.

The quickest way to "intermediate-expert" Linux IMO is learning system administration.

My go to book for this is "The Unix and Linux System Administration Handbook 5th edition"

https://www.amazon.com/UNIX-Linux-System-Administration-Handbook/dp/0134277554/ref=sr_1_1?keywords=The+Unix+and+Linux+System+Administration+Handbook+5th+edition&qid=1564448656&s=books&sr=1-1

This edition is updated recently to cover newer kernel features such as could environments and virtualization. This book also helps when learning BSD based stuff such as MacOS or FreeBSD.

Another good read for a "quick and dirty" understanding of Linux is "Linux Basics for Hackers" It does focus on a very niche distro and talks about tools that are not on all Linux systems BUT it does a good concise overview of intermediate things related to Linux (despite being called a beginners book).

https://www.amazon.com/Linux-Basics-Hackers-Networking-Scripting/dp/1593278551/ref=sr_1_3?crid=396AV036T1Y0Q&keywords=linux+basics+for+hackers&qid=1564448845&s=books&sprefix=linux+bas%2Cstripbooks%2C119&sr=1-3

There's also "How Linux works" but I cannot vouch for this book from personal use, I see it posted across various threads often. Never read this particular one myself.

https://www.amazon.com/How-Linux-Works-2nd-Superuser/dp/1593275676/ref=pd_bxgy_14_img_2/137-6604082-4373447?_encoding=UTF8&pd_rd_i=1593275676&pd_rd_r=feffef24-d3c3-400d-a807-24d8fa39cd1e&pd_rd_w=8GX0o&pd_rd_wg=3AMRB&pf_rd_p=a2006322-0bc0-4db9-a08e-d168c18ce6f0&pf_rd_r=WBQKPADCVSABMCMSRRA1&psc=1&refRID=WBQKPADCVSABMCMSRRA1

​

If you want a more programming oriented approach, if you're confortable with the C language, then you can always look at these books:

The Linux Programming Interface

https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=zg_bs_3866_1?_encoding=UTF8&psc=1&refRID=5YN3316W22YQ4TSMM967

Unix Network Programming VOL 1.

https://www.amazon.com/Unix-Network-Programming-Sockets-Networking/dp/0131411551/ref=sr_1_1?keywords=Unix+Network+Programming+VOL+1.&qid=1564448362&s=books&sr=1-1

Advanced Programming in the Unix Environment

https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739/ref=zg_bs_3866_2?_encoding=UTF8&psc=1&refRID=5YN3316W22YQ4TSMM967

These books would take you to understanding the kernel level processes and make your own and modify your own system.

As many have mentioned, you can go into these things with "Linux from scratch" but it's also feasible to do Linux from scratch by copy/pasting commands. Unless you tinker and fail at certain things (hence do it on a vm before doing it to the main system) you won't learn properly. I think the sysadmin approach is "safer" of the two options but to each their own.

I learned so much when I was in college from this book about C and the OS http://www.amazon.com/Programming-Environment-Addison-Wesley-Professional-Computing/dp/0321637739/ref=dp_ob_title_bk I haven't looked at the newest edition though.

You don't need a school for this.

Low Level Programming Languages

• http://www.buildyourownlisp.com/ - teaches you C and how to make your own lisp
  
• http://www.amazon.com/Interfaces-Implementations-Techniques-Creating-Reusable/dp/0201498413 - Must read
  
• https://stackoverflow.com/questions/562303/the-definitive-c-book-guide-and-list - More here
  
  For some Assembly
  
  
• http://www.nand2tetris.org/ - Course and book (free)
  
• http://www.amazon.com/The-Art-Computer-Programming-Vol/dp/0201896834 - Knuth teaches you how to approach any platform and code assembly for it. While you're at it, get Volume 2: Seminumerical Algorithms, Volume 3: Sorting and Searching and Volume 4A: Combinatorial Algorithms.
  
  Software Reverse Engineering
  Nostarch press/Wiley has books on this, plenty of defcon lectures. Watch 'Trolling with Math' as a way to defend against reverse engineering.
  
  Operating System Theory
  
  
• http://www.amazon.com/Lions-Commentary-Unix-John/dp/1573980137 The book on Unix theory.
  
• http://www.amazon.com/Programming-Environment-Addison-Wesley-Professional-Computing/dp/0321637739/ref=pd_cp_b_0 Modern programming on UNIX-like OSs and theory.
  
• http://eudyptula-challenge.org/ - build some custom linux kernel modules.
  
  Also look up MIT classes 6.004 and 6.033 they cover all this in detail. Can find vids online of record lectures, open courseware assignments and lecture notes, ect.
  
  Networking
  
  
• Grok OpenBSD's network stack. TC/IP is incredibly complex, you'll see why when you learn about it. Henning Brauer's papers about pf firewalls, network theory and weirdness in TC/IP checksums are here http://www.openbsd.org/papers/
  
• The above MIT classes.
  
  
  Cellular and Mobile Communications
  
  
• The Android Hacker's Handbook
  
• The iOS Hacker's Handbook
  
• Look up modern protocols like LTE
  
• Grok OpenBTS.org
  
  Discrete Math
  
  
• Take this course: http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-fall-2010/
  
• Read Sheldon Axler's Precalculus.
  
• Take Calculus Single and Multi Variable from MIT Open Courseware or coursera
  
• Read Sheldon Axler's Linear Algebra Done Right
  
• Take course on Logic from coursera/MIT
  
  Overview of Cyber Defense
  
  
• Network Security books: http://www.nostarch.com/catalog/security read Blackhat python, Security Data VIsualization for theory and detection, find some book somewhere on Security Architecture and read it for theory.
  
• Cryptography https://www.crypto101.io/ and Matthew D Green's course which posts lecture notes in the calender, or coursera.org courses. Do Matasano Crypto Challenges. Read Niels Ferguson's objections to XTS how when stored in a cloud, numerous new attacks are available for block cipher modes http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/comments/XTS/collected_XTS_comments.pdf so never use any block cipher on something that isn't actual hardware.
  
  Security Fundamental Principles (i.e., “First Principles”)
  Above material covers this
  
  Vulnerabilities
  
  
• http://courses.csail.mit.edu/6.857/2013/handouts
  
• Watch/Read security con lectures, Get a bughunting/rootkit book from NoStarch Press
  
  Legal
  No idea

You'll want APUE 3rd Ed for something like this.

I personally consider it a must-have.

Other things to note, you may/may not want to setrlimit for core dumps if you have sensitive information in the daemon. Calling fork() and then killing the parent is considered standard as is calling setsid(), closing all file handles and opening 0/1/2 to /dev/null.

Geany might be a friendly alternative to VS. Otherwise GCC-G++ and make files are your friend. A decent book to read on how to utilize the power of Linux with c/c++ is Advanced Programming in the UNIX Environment :

https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739

It will teach you about headers you won't find on Windows and how to program the whole operating system using c. But this can always be extended to c++ since c++ is a superset of c.😂

Just go straight to C++ then.

If not, http://shop.oreilly.com/product/9781565923065.do then https://www.amazon.com/Expert-Programming-Peter-van-Linden/dp/0131774298 then https://faculty.washington.edu/jstraub/dsa/Master_2_7a.pdf

I haven't read the last one, but I skimmed through it. You need that.

Hmm, what next? Ah, https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739 if that's your thing. You may find that online without having to buy it for the 2nd edition.

Oh, sockets... http://www.csd.uoc.gr/~hy556/material/tutorials/cs556-3rd-tutorial.pdf however, back when I studied those, I read beej's tutorial: http://beej.us/guide/bgnet/

You obviously don't need all of that. The first book I listed is enough, but maybe it'll be fun to work through them?

Assuming you're using Linux/Unix/BSD, this book will be invaluable: http://www.amazon.com/Advanced-Programming-UNIX-Environment-Edition/dp/0321637739

To start with, read up on select(), as that will be your friend. Doing something like this will be really tricky to get right.

Here you go: Advanced Programming UNIX Environment Edition.

This is the book that my university uses, should it help any: http://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720

I have it even though I've never taken any OS courses either. I've flipped through it and TBH, it looks like a pretty dry read :/ I'm still determined to sit down one of these days and get something out of it. Hopefully something else good turns up in this thread!

Oh, one other thing... if you want to start from "the base up" then you're going to have to learn a lot of Electrical Engineering and Signal Processing. If you want to start at the Computer Science layer, then you'll need to start at operating systems. For that, you should probably pick any operating system book with dinosaurs on the cover

aww my version doesn't looks as cool http://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720/ref=dp_cp_ob_b_title_1

The classics are generally the dinosaur book ( https://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720 ) or Tananbaum ( https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X ). Neither are terribly user friendly. Try /r/osdev -they're not hugely active but the sidebar resources should get you started.

There are three fundamental multithreading models:

• Many-to-One — Many user-level threads mapped to one kernel thread.
  
• One-to-One — One kernel thread per user-level thread.
  
• Many-to-Many — Many user-level threads multiplexed to a smaller or equal number of kernel threads.
  
  I recommend the dinosaur book for further reading.

I use [this one] (http://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720/ref=sr_1_1?ie=UTF8&qid=1369183975&sr=8-1&keywords=operating+systems)

You should start by picking one open source filesystem. EXT3 would be a good one. take a look at the source for it. Read the wikipedia entry and kernal documenation on it. make sure to google and understand the terminology in the documentation, because they are written with a level of jargon that assumes you know intimately what a 'journaling block device' layer is.. and other fundamental concepts.

EXT3 is relatively modern, and all the code is available to you, so you A) read through it, B) change it to see what happens to a VM drive filesystem or a physical practice hard drive file system, and C) benefit from community knowledge on it.

After you learn about EXT3, read up on other open source filesystems. All the code is there, making life easy. With the knowledge you get from that, you can more easily understand pros and cons of other filesystems, including proprietary ones.

There might be better ways, but that is how i would start. instead of EXT3, you could look at older EXT file systems for simpler examples.

Additionally, you may pick up a fundamentals of operating systems book, and make sure it has a chapter, or 10, on filesystems. 'Operating system concepts' is a book i like that has a chapter on distributed file systems that is good but assumes a lot of prior knowledge.

This is something I definitely want to attempt before taking my operating systems class...

It seems this is a common university level text on the subject:
http://www.amazon.com/gp/aw/d/0470128720/ref=redir_mdp_mobile?pc_redir=T1&tag=stackoverfl08-20

Any other recommendations?

CLRS is a great book and you'll likely need it in any reasonable CS dept. It's very heavy on the math and might be a bit over your head right now, but it's a solid book. It's a bit more than $50 but Operating Systems Concepts is also a good buy. I personally don't go for language-specific books since they quickly go obsolete, but books on fundamentals are very useful to have in your library.

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

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.

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.

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.

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.

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

No, that's operating systems.

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.

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.

I strongly recommend Understanding the Linux Kernel, 3rd Edition: http://www.amazon.com/Understanding-Linux-Kernel-Third-Edition/dp/0596005652

Although it's based on version 2.6 of Linux, I think its level of detail is unmatched.

How much time do you have?
How much do you know related to low-level hardware and how things work close to the “metal”?

You can get a decent understanding by googling/looking at blogs that try to approach this subject. There are also a couple of book that are free to read on github.

If you want to go really deep I recommend a book https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652
Although it’s pretty old and refers to 2.6 kernel it’s one of the best books I’ve ever seen if you’re interested in the Linux Kernel (booting included).
After you learn/come across some of the fundamental notions explained in this book it’s going to be easier to grasp and understand other more advanced material or even look at the kernel source code yourself.

Understanding the Linux Kernel is great and, obviously, very specific to Linux.

​

Linus has cited that he read Bach's book about the design and implementation of UNIX as inspiration for the development of Linux.

​

Read both and really enjoyed them! I hope you like!

The tutorials linked at the top-level README of the repo are great. If you want more detail, I'd recommend the books:

• Modern operating systems
  
• Understanding the Linux kernel
  
  Those are the ones we used in college and they're pretty good, though more dense and thorough.
  
  Good luck!

There is an OReilly book

http://www.amazon.com/Understanding-Linux-Kernel-Third-Edition/dp/0596005652

har har on the boots...

And I'm not talking about how to use these things, I'm talking about how they work on a very low level. I know how to use grub. I now want to know how grub works (and rEFIt and bcd stuff) and what they are doing through every step. Think this, but for everything up until you load the kernel, or run ntoskrnl.exe, or whatever.

By beginner I'm guessing you mean to programming in general. Head Firsts C# book was absolutely fantastic for teaching the beginnings and getting me started.

http://www.amazon.com/Head-First-C-Andrew-Stellman/dp/0596514824

I started at 23, and I can tell you that people who start out younger are usually considerably sloppier and much more clueless about what their code is doing than people who start older.

This started me:

http://www.amazon.com/Head-First-C-Andrew-Stellman/dp/0596514824

http://www.amazon.com/Head-First-Python-Paul-Barry/dp/1449382673

Ok then yeah Github isn't bad then. It works nicely in Visual Studio or Visual Code. I personally use the command prompt for it(it's how I was taught, but generally I prefer GUIs).

Not sure what book you are gonna need but I learned C# with Head First C#. It is easy to follow and has great examples.

Head First C# https://www.amazon.com/dp/0596514824/ref=cm_sw_r_cp_apa_CEMRzbPTBG8BG

I have not read that book, so I can't really comment on it. Amazon reviews seem ok, but based on reviews, Head First C# may be a more appropriate beginner book.

It is four years old now but "Linux Kernel Development" http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468
despite the name, the book is also nice even for people not doing kernel development.

Yeah, the beauty of the low level libraries is they really do not change very much or often. I do not expect everyone to master them, but having an understanding will help in any area of userspace you work. Here are two great books that can be read with just an understanding of the c language.


http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200/ref=sr_1_10?ie=UTF8&qid=1404953887&sr=8-10&keywords=linux


http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468/ref=pd_sim_b_1?ie=UTF8&refRID=10S29ZMT4Q5VQM4KYZRY

I enjoyed Linux kernel development by Robert Love.
He starts with a high level view, just to understand the concept, and then points you to the relevant code in the kernel.
But as with all books about the kernel, references become outdated but not too hard to find it in recent kernels.

• Malware Analyst's CookBook is pretty good, lots of examples of techniques with example code.
  
• The Rootkit Arsenal is also supposedly really good.
  
• The Shellcoders Handbook (2nd edition) will help you get up to speed with mainstream exploitation techniques.
  
• Linux Kernel Development is a short read and describes the architecture of the Linux Kernel. Also explains many basic Operating System concepts.
  
• UNIX Network Programming, Volume 1: The Sockets Networking API (3rd Edition) introduced IP/IPv6/IPSec/TCP/UDP/SCTP as well as the POSIX Socket API.
  
• Cannot stress this enough, pickup your choice of a C/C++/Java/C#/Python/Ruby/etc book. Having a solid understanding of a programming language will make life much easier.

"Linux Kernel Development" by Robert Love is also good
http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468

While being a self taught sys admin is great, learning the internals of how things work can really extend your knowledge beyond what you may have considered possible. This starts to get more into the CS portion of things, but who cares. It's still great stuff to know, and if you know this you will really be set apart. Im not sure if it will help you directly as a sys admin, but may quench your thirst. Im both a programmer and unix admin, so I tend to like both. I own or have owned most of these and enjoy them greatly. You may also consider renting them or just downloading them. I can say that knowing how thing operate internally is great, it fills in a lot of holes.

OS Internals

While you obviously are successful at the running and maintaining of unix like systems. How much do you know about their internal functions? While reading source code is the best method, some great books will save you many hours of time and will be a bit more enjoyable. These books are Amazing
The Design and Implementation of the FreeBSD Operating System

Linux Kernel Development
Advanced Programming in the UNIX Environment

Networking

Learning the actual function of networking at the code level is really interesting. Theres a whole other world below implementation. You likely know a lot of this.
Computer Networks

TCP/IP Illustrated, Vol. 1: The Protocols

Unix Network Programming, Volume 1: The Sockets Networking API

Compilers/Low Level computer Function

Knowing how a computer actually works, from electricity, to EE principles , through assembly to compilers may also interest you.
Code: The Hidden Language of Computer Hardware and Software

Computer Systems: A Programmer's Perspective

Compilers: Principles, Techniques, and Tools

I bought it from this link:

http://www.amazon.com/gp/aw/d/0672329468?pc_redir=1397146287&robot_redir=1

It's literally called Linux Kernel Development by Robert Love.

I am not sure which books are recommended nowadays but for me years ago it was: https://www.amazon.com/Python-Essential-Reference-David-Beazley/dp/0672329786/

But this one is mostly about Python2, though a new edition might be on its way.

Novice here. I bought the Python Essential Reference at the advice of this thread when I ran into some frustrations with O'Reilly (Learning Python, 4th Ed). They both have their issues. Essential reference is written for a higher-level audience, but I think it does a better job illustrating concepts by example. By contrast, the O'Reilly is more oriented toward beginners, but it's weirdly averse to including actual code snippets, so you get very little immersion in the syntax. Also the organization of the contents is extremely arbitrary, such that if you read it in a straight line you'll encounter an example of a nested dictionary prior to learning basic dictionary operations, and list comprehensions before lists. Steer clear.

> so the book that is a reference on 2.6 and 3 at the same time is a lot more useful!

Try Python Essential Reference (4th Edition).

Seeing you know perl this might help
http://www.amazon.com/Python-Essential-Reference-David-Beazley/dp/0672329786

> It's never been compulsory unless you're bad at programming.

Or, back then, part of the policy of the shop at hand that use strict be used or be written up. So yeah, still compulsory.

> The only particularly Perl-ish one is the statement if condition.

Yup, that's the one. That was the moment I decided to leave Perl since it was clear that the language was not designed with maintenance in mind.

First up is the unless statement, it's shorthand for if !. Except we don't have an elsunless like elsif. So subsequent statements in the chain which are also not statements still have the if ! notation. So to be consistent when we have to add on additional if ! it is best to rewrite the first into a if ! from unless.

The statement if condition usage has no else or elsif at all. So if later we need to have chaining conditions we need to rewrite that portion into the standard if condition format.

Why does this matter?

Because to make my code maintainable just to myself all those years ago I made the decision to not use the unless or condition if forms and limit myself to to the if condition format. This way when I came back to the code months later to add in some new requirement from on high I knew exactly what I was getting into.

The problem is, I wasn't the only Perl hacker in the shop. So every damn time I had to touch someone else's code or they touched mine it felt more like a rewrite than a simple modification.

That frustration came to a head when I went to the O'Reilly conference in Monterey back in... 2000? Instead of focusing on Perl presentations I hit up a Python presentation put on by Beazley himself. Python's focus on one clear way to achieve something was so refreshing compared to tossing out 75% of Perl's TIMTOWDI mish-mash.

> If you're going to bitch about having lots of different ways to accomplish a task (despite the Perl mantra, TIMTOWDI..), pick "iterate a list" or the ridiculous number of ways for can be used.

This is true. I, however, choose if as an example because it is easy to explain, even to laypeople, as to why I ran screaming from the Perl world back then.

(Edits for late night typos).

What initially caught my attention was the example used throughout the course (a stock portfolio). Using the example below, he walks through different scenarios while increasing the difficulty (goes from scripts, functions, classes including Inheritance, Encapsulation, iterators and Generators, Coroutines, etc), and explains everything along the way.

For example, he’s like what If this was a csv file and I wanted to read it? What if I wanted to create data quality checks? What if I wanted to create a class to handle reading this file? What if I wanted to create a class to output the portfolio in html? Csv file? So on, and so on.
Even though I didn't really understand anything past classes (until I watched the video like 10 times), I was reassured by who was presenting (Beazley seems to be kind of a rockstar in Python community) and ultimately decided that what he was talking about was worth knowing.

https://www.amazon.com/Python-Essential-Reference-David-Beazley/dp/0672329786



example used in course:

name, date, shares, price

AA,2007-06-11,100,32.20

IBM,2007-05-13,50,91.10

CAT,2006-09-23,150,83.44

MSFT,2007-05-17,200,51.23

GE,2006-02-01,95,40.37

MSFT,2006-10-31,50,65.10

IBM,2006-07-09,100,70.44

Also coming from PHP here, I got the "Python Essential Reference" from David Beazley and I must say that I like it very much. It's not a introductory book on programming - it assumed that you know programming very well and just need to learn the ins and outs of python. It's pretty direct-to-the-point and well written. I highly recommend it. http://www.amazon.com/Python-Essential-Reference-David-Beazley/dp/0672329786/ref=sr_1_1?ie=UTF8&s=books&qid=1261867689&sr=8-1

I recommend you jump on to the Python bandwagon and start learning Django. The main site is http://www.djangoproject.com/. It has nice documentation http://docs.djangoproject.com/en/dev/ but the code is also very helpful to read. I would wager that if you could learn Python quickly by reading the Django code and learning some of the more advanced topics (https://code.djangoproject.com). There are two very helpful Groups on Google: Django-users (http://groups.google.com/group/django-users) and Django-developers (http://groups.google.com/group/django-developers -- think of this as read-only).

You've said you've dabbled in Python so I assume you know the resources there but two of my favorite books are Python in a Nutshell (http://oreilly.com/catalog/9780596001889) by Alex Martelli who is a genius and very involved with the online community. Despite the book's age, Mr. Martelli's experience with Python will quickly inform you of the nuances and pleasures of working with the language. Finally, I just picked up a copy (4th edition) of David Beazley's (http://www.amazon.com/Python-Essential-Reference-David-Beazley/dp/0672329786/ref=dp_cp_ob_b_title_1) Python Essential Reference. A lot of it overlaps the Martelli book but it is updated for the most recent Python versions 2.6/3.X. I would buy both books and jump in. Note that they are reference books but since you have programming experience, I find them to be excellent "jump in" tutorials and of course essential references when coding.

Finally, to get a feel for best practices, see Dive into Python by Mark Pilgrim -- another great Pythonista the Python community values as he is very smart and can communicate well to the readers (plus he likes open source and his universal feed parser is great! and the book is free) -- http://www.diveintopython.org .

Contact me by using http://www.ryankaskel.com/contact-me/ if you find yourself strapped of cash and I would be happy to help you become a Pythonista.

I found this book very useful moving from Java to Python David Beazley Python Essential Reference

Intermediate:
Python Essential Reference

Code is also a good book. If you want textbooks:

This is a good one for computer architecture. And there's a companion course/website at www.nand2tetris.org. https://www.amazon.com/Elements-Computing-Systems-Building-Principles/dp/0262640686/ref=ed_oe_p

I like this one as far as operating systems go: https://www.amazon.com/gp/aw/d/1118063333/ref=dp_ob_neva_mobile

For learning programming, I would check out courses at www.udemy.com. But be mindful of ratings & reviews because the quality of courses can vary pretty drastically. But I've had good experiences there. www.udacity.com also has great courses. They offer paid nanodegrees but you can take every individual course free of charge. www.teamtreehouse.com is another good website

If you're interested in networking, this is a good book for starters: https://www.amazon.com/gp/aw/d/0768685761/ref=dp_ob_neva_mobile

Any A+/Network+ certification books or courses would also be a great way to learn networking and computer hardware

Those are pretty big topics in tech & computer science. There's a ton of stuff to learn. I've been studying this stuff for probably 2-3 years and sometimes I feel like I've barely scratched the surface. Let me know if that helps & if there are other topics you'd want book recommendations on! :)

Concurrency has quite a bit of theory involved. A good chunk of time is spent on it in courses on the theory of operating systems. Here's one text frequently used in such courses (older editions should be fine, too):

https://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/1118063333/

As a sysadmin and PC builder, there are almost no common skills between the two. I rarely ever physically touch hardware at work any more. Even then, it's just racking and cabling a newly purchased server or storage array, turning it on, and walking away. Anybody could do that, though, and the rest happens in software. I don't even touch them when hardware fails -- modern systems have diagnostics that tell you exactly what part in what slot is broken to the point of flashing an LED next to it; some of our storage arrays even automatically order their replacement parts. Swaps are all tool-less, and again, pretty much anyone could do it, so we have operations people who go around and change things out.

I guess the only commonality is that sysadmins and PC builders both install and use operating systems, but that's not really a skill, either. Even that I did one time at work, built a template, and scripted everything so that someone can do the next one by answering a few questions and clicking a button.

Not that I would dissuade OP from becoming a sysadmin if he's interested in the work; just the opposite. It can be a really interesting job, pay is generally several times the median, and you get to work with some really cool tech depending on the industry you're in. OP, if you're interested in this field, my advice would be to learn, in depth, how operating systems work. Get a copy of Operating System Concepts and learn it. Learn C and look at one or more of the open-source Unix/Unixlike kernels to understand how practical implementation differs from theory. This will all cost you $200 and some time (well, a lot of time).

Once you have done this, you're ready to get yourself whatever you need to get a job (maybe some college, some experience at a small company, the usual industry certifications, etc., in whatever combination works for you; I went to college and wrangled myself some work experience back in the nineties when the job market was so good anyone could get one, your approach may be different now.)

> For those who prefer video lectures, Skiena generously provides his online. We also really like Tim Roughgarden’s course, available from Stanford’s MOOC platform Lagunita, or on Coursera. Whether you prefer Skiena’s or Roughgarden’s lecture style will be a matter of personal preference.
>
> For practice, our preferred approach is for students to solve problems on Leetcode. These tend to be interesting problems with decent accompanying solutions and discussions. They also help you test progress against questions that are commonly used in technical interviews at the more competitive software companies. We suggest solving around 100 random leetcode problems as part of your studies.
>
> Finally, we strongly recommend How to Solve It as an excellent and unique guide to general problem solving; it’s as applicable to computer science as it is to mathematics.
>
>
>
> [The Algorithm Design Manual](https://teachyourselfcs.com//skiena.jpg) [How to Solve It](https://teachyourselfcs.com//polya.jpg)> I have only one method that I recommend extensively—it’s called think before you write.
>
> — Richard Hamming
>
>
>
> ### Mathematics for Computer Science
>
> In some ways, computer science is an overgrown branch of applied mathematics. While many software engineers try—and to varying degrees succeed—at ignoring this, we encourage you to embrace it with direct study. Doing so successfully will give you an enormous competitive advantage over those who don’t.
>
> The most relevant area of math for CS is broadly called “discrete mathematics”, where “discrete” is the opposite of “continuous” and is loosely a collection of interesting applied math topics outside of calculus. Given the vague definition, it’s not meaningful to try to cover the entire breadth of “discrete mathematics”. A more realistic goal is to build a working understanding of logic, combinatorics and probability, set theory, graph theory, and a little of the number theory informing cryptography. Linear algebra is an additional worthwhile area of study, given its importance in computer graphics and machine learning.
>
> Our suggested starting point for discrete mathematics is the set of lecture notes by László Lovász. Professor Lovász did a good job of making the content approachable and intuitive, so this serves as a better starting point than more formal texts.
>
> For a more advanced treatment, we suggest Mathematics for Computer Science, the book-length lecture notes for the MIT course of the same name. That course’s video lectures are also freely available, and are our recommended video lectures for discrete math.
>
> For linear algebra, we suggest starting with the Essence of linear algebra video series, followed by Gilbert Strang’s book and video lectures.
>
>
>
> > If people do not believe that mathematics is simple, it is only because they do not realize how complicated life is.
>
> — John von Neumann
>
>
>
> ### Operating Systems
>
> Operating System Concepts (the “Dinosaur book”) and Modern Operating Systems are the “classic” books on operating systems. Both have attracted criticism for their writing styles, and for being the 1000-page-long type of textbook that gets bits bolted onto it every few years to encourage purchasing of the “latest edition”.
>
> Operating Systems: Three Easy Pieces is a good alternative that’s freely available online. We particularly like the structure of the book and feel that the exercises are well worth doing.
>
> After OSTEP, we encourage you to explore the design decisions of specific operating systems, through “{OS name} Internals” style books such as Lion's commentary on Unix, The Design and Implementation of the FreeBSD Operating System, and Mac OS X Internals.
>
> A great way to consolidate your understanding of operating systems is to read the code of a small kernel and add features. A great choice is xv6, a port of Unix V6 to ANSI C and x86 maintained for a course at MIT. OSTEP has an appendix of potential xv6 labs full of great ideas for potential projects.
>
>
>
> [Operating Systems: Three Easy Pieces](https://teachyourselfcs.com//ostep.jpeg)
>
>
>
> ### Computer Networking
>
> Given that so much of software engineering is on web servers and clients, one of the most immediately valuable areas of computer science is computer networking. Our self-taught students who methodically study networking find that they finally understand terms, concepts and protocols they’d been surrounded by for years.
>
> Our favorite book on the topic is Computer Networking: A Top-Down Approach. The small projects and exercises in the book are well worth doing, and we particularly like the “Wireshark labs”, which they have generously provided online.
>
> For those who prefer video lectures, we suggest Stanford’s Introduction to Computer Networking course available on their MOOC platform Lagunita.
>
> The study of networking benefits more from projects than it does from small exercises. Some possible projects are: an HTTP server, a UDP-based chat app, a mini TCP stack, a proxy or load balancer, and a distributed hash table.
>
>
>
> > You can’t gaze in the crystal ball and see the future. What the Internet is going to be in the future is what society makes it.
>
> — Bob Kahn
>
> [Computer Networking: A Top-Down Approach](https://teachyourselfcs.com//top-down.jpg)
>
>
>
> ### Databases
>
> It takes more work to self-learn about database systems than it does with most other topics. It’s a relatively new (i.e. post 1970s) field of study with strong commercial incentives for ideas to stay behind closed doors. Additionally, many potentially excellent textbook authors have preferred to join or start companies instead.
>
> Given the circumstances, we encourage self-learners to generally avoid textbooks and start with the Spring 2015 recording of CS 186, Joe Hellerstein’s databases course at Berkeley, and to progress to reading papers after.
>
> One paper particularly worth mentioning for new students is “Architecture of a Database System”, which uniquely provides a high-level view of how relational database management systems (RDBMS) work. This will serve as a useful skeleton for further study.
>
> Readings in Database Systems, better known as the databases “Red Book”, is a collection of papers compiled and edited by Peter Bailis, Joe Hellerstein and Michael Stonebreaker. For those who have progressed beyond the level of the CS 186 content, the Red Book should be your next stop.
>
> If you insist on using an introductory textbook, we suggest Database Management Systems by Ramakrishnan and Gehrke. For more advanced students, Jim Gray’s classic Transaction Processing: Concepts and Techniques is worthwhile, but we don’t encourage using this as a first resource.
>

> (continues in next comment)

Haven't read it, however you could probably look at this https://www.amazon.co.uk/C-7-0-Nutshell-Joseph-Albahari/dp/1491987650/ref=sr_1_5?keywords=C%23&qid=1563967181&s=gateway&sr=8-5 however if you just want to learn the basics you could just watch youtube tutorials and go from there

I would suggest C# In A Nutshell. I consider it the definitive reference for people who already know a bit of programming.

https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

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:

1. http://www.amazon.com/Beginning-Linux-Programming-Neil-Matthew/dp/0470147628/ref=sr_1_2?s=books&ie=UTF8&qid=1450511098&sr=1-2&keywords=LINUX+Programming
   
   
2. http://www.amazon.com/Linux-System-Programming-Talking-Directly/dp/1449339530/ref=sr_1_4?s=books&ie=UTF8&qid=1450511098&sr=1-4&keywords=LINUX+Programming
   
   
3. http://www.amazon.com/Linux-Programming-Example-Arnold-Robbins/dp/0131429647/ref=sr_1_5?s=books&ie=UTF8&qid=1450511098&sr=1-5&keywords=LINUX+Programming
   
   EDIT: Formatting

So there's this book called The Linux Programming Interface by Michael Kerrisk. Some consider it being the book.

I know this is not specifically for kernel development, but The Linux Programing Interface Handbook is a great book for better understanding how to program for Linux systems.

Try gvim (vim-gtk, vim-gnome). I use it on Windows and Linux. You can remap the CTRL commands to the Windows equivalent, see Superuser question here: "How to make cut/copy/paste in GVim on Ubuntu work with Ctrl+X,Ctrl+C,Ctrl+V?"

Vim is made for touch-typists; you are definitely at a disadvantage when you can't touch type. That's true for every kind of editor but with vim the speed difference between a touch typists and a non-touch typists is even bigger.

Book recommendation: Practical Vim: Edit Text at the Speed of Thought

https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

I found both Learning the vi Editor and Practical Vim to be excellent learning resources. In addition, of course, to browsing the docs and using, using, using the editor.

Came here to suggest the Albahari as a desk reference, I go back to mine constantly.

Protip: the writer of linqpad, also has some nice articles.

The built in tutorial will get you started.

Practical Vim http://www.amazon.com/Practical-Vim-Thought-Pragmatic-Programmers/dp/1934356980/ref=sr_1_1?ie=UTF8&qid=1414952123&sr=8-1&keywords=practical+vim is what really got me to understand how it works, and was far more effective than looking at various online tutorials. It goes much more into how one can actually use the various tools effectively. Vim is very personal, with many ways to skin a cat. This goes through examples of several ways to deal with the same problem, and really lets you understand how the tools fit together.

Have you taken a look at The Linux Programming Interface?

As others have said, K&R is great for learning the C language. In addition to that, Algorithms in a Nutshell is a nice reference because it has sample code in C for a lot of major data structures and algorithms, so you can see how the language is used to implement CS concepts you might already be familiar with.

I would also highly recommend one or both of Advanced Programming in the Unix Environment or The Linux Programming Interface, which will get you up to speed on POSIX.

My General Thought

I find it is best to learn and get exposure from several book/media sources coupled with actual application of things learned.

----

Introductory Texts/Links

Short Intro
http://heather.cs.ucdavis.edu/~matloff/unix.html

C Programming: A Modern Approach
http://knking.com/books/c2/index.html

Head First C (Different Presentation Style, check amazon preview)
http://www.amazon.com/Head-First-C-David-Griffiths/dp/1449399916/

Programming in C
http://www.amazon.com/Programming-C-4th-Developers-Library/dp/0321776410/

PDF Tutorial
http://phy.ntnu.edu.tw/~cchen/pdf/ctutor.pdf
Original Here > http://www.tutorialspoint.com/cprogramming/index.htm

C The HardWay (Mostly complete)
http://c.learncodethehardway.org/book/

Zed's K&R Critique
http://c.learncodethehardway.org/book/krcritique.html

Practical C Programming
http://shop.oreilly.com/product/9781565923065.do

Ben Klemens Modeling with Data book has a short C introductory section.
http://ben.klemens.org/pdfs/gsl_stats.pdf

-----

Reference
Harbison and Steele C Reference Manual
http://www.careferencemanual.com/

Plan on developing on Linux?
The Linux Programming Interface: A Linux and UNIX System Programming Handbook
http://www.amazon.com/dp/1593272200/

Didn't get Pointers?
http://www.amazon.com/dp/1449344186/

21st Century C, This book got dogged a lot, but I think its a nice text.
http://www.amazon.com/21st-Century-Tips-New-School/dp/1449327141

K&R Scan (If you want an idea what's inside K&R)
http://www.iups.org/media/meeting_minutes/C.pdf

-----

Need an Editor?
VIM Book
ftp://ftp.vim.org/pub/vim/doc/book/vimbook-OPL.pdf

Vim Video Tutorials
http://derekwyatt.org/vim/

-----

Back in the Day
I used these books years ago. They're somewhat dated, but still useful and cheap.
Programming in ANSI C
http://www.amazon.com/Programming-ANSI-Hayden-Books-library/dp/0672484080
Advanced C: Tips and Techniques (Hayden Books C Library)
http://www.amazon.com/Advanced-Techniques-Hayden-Books-Library/dp/067248417X/

----

C Language Basics
How do I read/write files
How things are implemented at a lower level
Compiler Options and Functionality
What is a make file?
Debugging... How to do it... How do I use a standard debugger like GDB?

For Linux internals read https://www.amazon.ca/Linux-Programming-Interface-System-Handbook/dp/1593272200 , you only need the intro to each chapter (before he gets to code).

For general Linux read https://www.amazon.ca/UNIX-Linux-System-Administration-Handbook/dp/0134277554/

You need to know some concepts very well, like life of a process and signals (may not pass initial screen interview without those), as well as basic networking (both google and facebook have a networking interview although it’s valued less than the others).

Btw there’s also an interview about designing a distributed systems, best source to learn is to read about tools at google, facebook and AWS.

For troubleshooting, there’s no book, it’s all practice with real problems. If I had the time or rather the priority, I’ll publish a bunch of broken things in docker containers as exercises but it’s a lot of work.

I do have a troubleshooting framework , with things like verify given information, trying to break the problem space in two , do first easy quick tests etc

Buy (/borrow/steal) The Linux Programming Interface by Michael Kerrisk. It's Stevens' APUE for the 21st century, and is well worth the price. Everything you can possibly do programmatically on Linux will be explained in detail there, including process management, threads, filesystems API, memory management, IPC, the Linux ABI, and so on.

Thinking back on it now I think K&R C needs to be coupled with [the linux programming interface] (http://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=sr_1_1?ie=UTF8&qid=1411641367&sr=8-1&keywords=linux+programming+interface). It really helps flesh out the parts where K&R leaves you hanging. It also shows you the internals of c programs and much more.

I have heard good things about The Linux Programming Interface but cannot verify it is as specific as you are looking for.

I think some of Julia Evans stuff is good for this.

https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200

I'm a fan of this book: http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200

It has way too much detail but it is organized well.

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.

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.

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.

This book is how I first learned. https://www.amazon.com/Practical-Guide-Commands-Editors-Programming/dp/013308504X

https://www.amazon.com/Practical-Guide-Commands-Editors-Programming/dp/013308504X

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.

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.

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

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

Honestly I think you might learn more from this book:

https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X

Modern Operating Systems (4th... https://www.amazon.com/dp/013359162X?ref=ppx_pop_mob_ap_share

When/if you get to the point where you want to learn more about multithreading, this is a good resource.

Hit the books ! More specifically this one : https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X it’s a great book, it explains the concepts really well and also has code examples. Tho I recommend reading about computer architecture a bit to understand it better, this is also a great book for it https://www.amazon.com/Computer-Organization-Architecture-William-Stallings/dp/0134101618
But really read all of the tanenbaum’s book, I got an A because of it, it’s an amazing book.

Modern Operating Systems

One of the best starter Comp Sci books.

When you say you want to make a simplistic OS, do you mean you want to put together a simplistic Linux distro, or you want to code an OS from scratch?

In former case DSL might be your friend (Damn Small Linux):
http://www.damnsmalllinux.org/. There are other similar distros that might fit under 25 megabyte, google is your friend. As already mentioned by somebody else linuxfromscratch.org is another option. If you go with LFS, you want to look at minimal libraries instead of standard GNU libs for C library and standard system applications. For example you would like to get https://www.uclibc.org/ for c library (or some other similar, there are few) and say busybox https://www.busybox.net/ for your system apps. There other "micro" versions of some popular software (X server etc) which you might wish to consider if you are going completely custom route.

If I was you, I wouldn't do it, since many others have same thoughts as you and have already put effort and hours into making it, so why repeating all that work if you can just get a distro like DSL and install it and simply customize/change what you dislike. If you want it as an educational experience than certainly go for it, LFS might be very rewarding in that case.

If you want to code your own kernel and OS, than you might wish to take a CS class about OS:s, Tanenbaum is your eternal friend:
https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X/ref=sr_1_1?ie=UTF8&qid=1498831929&sr=8-1&keywords=andrew+tanenbaum

https://www.amazon.com/Structured-Computer-Organization-Andrew-Tanenbaum/dp/0132916525/ref=sr_1_4?ie=UTF8&qid=1498831929&sr=8-4&keywords=andrew+tanenbaum

And don't forget Google ...

You'll need to have some experience coding a few hundred lines and also have experience using a debugger. You'll also be expected to do readings which I highly recommend and the concepts are not that trivial; you'll need to wrap your head around concepts in 369 until it finally clicks. Implementing them in C isn't too bad, make good use of office hours and tutorials. Worst case scenario just get a good partner.

here's the textbook I was assigned, its a good read too: https://www.amazon.ca/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X

http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X

My professor recommended the book "Modern Operating Systems" for one of our classes. It's certainly not for everyone, the class was split about 50/50 on whether they absolutely hated it or loved it. There are copies to be found online if you're interested in checking out the writing-style, but I seriously recommend buying it if you do enjoy it as it is clearly a product of passion.

It's been an absolutely fantastic resource to me and although, as the name implies, it mostly focuses on operating systems, they manage to strike a seemingly perfect balance between explaining concepts of operating systems while still giving a thorough review of what role the actual hardware plays in the mix and how that works as well.

>> You are confusing sections with segments

> and you're behaving the way C++ usually behave

I am not a C++ anything. I have 25 years of experience with C and 20 years of experience with operating system design and development. The odds are better than even that both the computer you used to post this abusive rant and the computers which reddit use to store and serve it run code that I have written.

(Yes, I've been writing C++ on and off for almost as long as I've been writing C, but I vastly prefer the latter.)

> code section or code segment or text section or test segment are same in this context

Absolutely not. Segments are a feature of some computer architectures, most prominently the Intel 8086 and 80386 (but not their 64-bit descendants), used to organize and access code and data in memory. Sections are a feature of most executable file formats (such as ELF and COFF) used on modern non-embedded platforms. The OS and / or the run-time linker read code and data from sections in the executable file and store them somewhere in memory.

> simple googling gives you the result: https://stackoverflow.com/questions/2589949/string-literals-where-do-they-go

Stack Overflow is not a reliable source of correct* information (see for instance this article or this one about how SO's karma system encourages a race to the bottom). I would suggest reading Tanenbaum or McKusick et al. instead.

This specific answer is correct only in the sense that the literals are included in the same file as the code. Setting aside embedded platforms and their idiosyncrasies, they are stored in different sections of the file and loaded into different memory locations at run-time.

> Where do they go? the same segment where the .text section of the object file gets dumped, which has Read and Exec permissions, but not Write

Your information is 20 to 30 years out of date. No modern OS uses segments the way Intel envisioned when they designed the 8086 or the 80386. The former needed segments to escape pointer size limitations when the address bus outgrew the registers, and the latter retained them for backward compatibility and added memory protection features on a per-segment basis. However, modern OSes for the 80386 and its descendants implement memory protection at the page table level rather than at the segment level and use segment registers purely as conveniences for array operations, which is why they were left out when the 80386 architecture was expanded to 64 bits.

> But go ahead c++ pleb continue **** your *** like your kind always does.

I understand that it can be hard to admit that you are wrong, but that's not a reason to resort to that kind of language.

What I know, I learned from a book. Unfortunately, the book was purchased before Amazon, Kindle, etc. so I only have it in physical form far away from where I find myself physically right now so I can't remember the name. This one is probably very good (maybe even a newer edition of the same).

udacitiy courses from google
and this book: https://www.amazon.com/Android-Programming-Ranch-Guide-Guides/dp/0134706056/ref=sr_1_1?ie=UTF8&qid=1522707706&sr=8-1&keywords=android+programming+big+nerd+ranch

These guys at the nerd ranch are pro as f... at least for Android and iOS

https://www.amazon.com/Android-Programming-Ranch-Guide-Guides/dp/0134706056/ref=sr_1_2?ie=UTF8&qid=1487904695&sr=8-2&keywords=big+nerd+ranch

I personally learned from devslopes (http://devslopes.com)

I'm wondering how much Java would I need to know to start developing apps. I learned it during college as part of my program, but outside of that I haven't used it at all. I have a decent amount of understanding of the fundamental of programming (object oriented, polymorphism, etc). Would this be enough or should I consider getting some resource such as this book to brush up on it.

Also any thoughts on this book to learn android dev?

Is this the book you speak of?

https://www.amazon.com/Android-Programming-Ranch-Guide-Guides/dp/0134706056

Android Programming from Big Nerd Ranch. Here's the link on Amazon.

In my experience, books work great for non-fiction too. I read Modern Operating Systems by Andrew Tanenbaum and learned more about operating systems faster than I could online. Yes, all of the information is online and easily accessible, but by putting all of that information into a single 1000 page book, the author can more easily control how you learn the information. Instead of reading scattered fragmentary articles on individual parts of an operating system, many of which assume you know about more advanced topics, you can read a book and the author will start you off with simple groundwork, then more to more advanced stuff while making sure that you know everything leading up to that point. Even though the book was several years outdated when I read it, the knowledge that I gained from it let me learn about more recent topics easier.

A book, by virtue of its very long format, can more easily present information in a structured and progressive manner that ensures that the reader truly learns the information presented. Of course, everyone learns differently, but I personally like how a book guides me through the topic.

Try having a look at this book http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639. I've only got past the first chapter or so but it may answer some of your questions.

I'd recommend Tanenbaum's Modern Operating Systems, that should get you started on beginning to understand what goes on inside your computer. If you'd like further reading and you want a mental beat-down, you can't go wrong with Knuth's The Art of Computer Programming. Want to start with programming? One of my favorites is The C Programming Language by K&R. Those three recommendations, while they add up to a single semester's tuition, are worth way more than that. Good luck!

OSDever

Solaris: Internals was also really good, combined with Tannenbaum's book (not the Minix book, the good one)

They're not really covered as a distinct topic - you'll tend to see them wrapped up in other books from what I've seen. Sorry this is not going to be as simple of an answer as you're hoping for, but I'm trying to give you a clear picture. I don't know of one good book - maybe, hopefully someone else does.

There's the theoretical side, covering parallel execution models. Look for senior undergrad or graduate level parallel algorithms courses. There should be lots of material online. Some good discussion here: https://developer.nvidia.com/content/what-are-your-favorite-parallel-programming-references

On the practical side, pthreads is probably the most commonly used threading library in the non-Windows world and is not that hard to learn from example. None of the individual concepts are that hard, it just introduces great potential for complexity and tough debugging when you have a bunch of locks scattered throughout your program and you're trying to make sure you're always acquiring and releasing them in the same order, as one example problem.

If you learn all that and then add in some atomic operations and non-blocking algorithms, and maybe message passing, all of which are fairly tractable to learn by searching for examples, you should be in pretty good shape.

I also like the OS perspective on this stuff. Tanenbaum covers this well if I remember right.

The two Andrew Tanenbaum books are usually a really good place to start.

Operating Systems: Design and Implementation

Modern Operating Systems

They are admittedly x86 based books, but they'll introduce you to actual OS design concepts, and then it's a "simple" matter of actually digging in to the documentation for the hardware you're writing it for and then start building.

Andrew Tanenbaum (guy who made MINIX) has a pretty decent book on Operating Systems. It has had a number of iterations, here is one.

http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639?tag=r601000010-20

I don't personally own it, but my friend who built an OS in his free time gives it his highest recommendation.

I just have a copy of Kernighan & Pike's Unix Programming Environment for my 1 year old. He seems to like it as much as the other books he has.

A lot of Kernighan’s (co‐authored) books age surprisingly well. It’s a real testament to his writing style that they are still relevant today despite examples tending to be in PL/I or Fortran.

• The Elements of Programming Style
  
• Software Tools
  
• The Practice of Programming
  
• The Unix Programming Environment
  
  And, of course…
  
  
• The C Programming Language

> Is there some sort of golden rule book whose laws must not be violated?

Yes. The Design of the UNIX operating system and there's The UNIX Programming Environment :\^)

First note that Career/Job/Market is quite different from Knowledge/Intellectual satisfaction. So you have to keep "earning money" separate from "gaining knowledge" but do both parallely. If you are one of the lucky few who has both aligned in a particular job, you have got it made. Mostly that is never the case and hence you have to work on your Motivation/Enthusiasm and keep hammering away at the difficult subjects. There are no shortcuts :-)

I prefer Books to the Internet for study since they are more coherent and less distracting, allowing you to focus better on a subject. Unless newer editions are reqd. buy used/older editions to save money and build a large library. So here is a selection from my library (in no particular order);

• Digital Design and Computer Architecture
  
  
• Foundations of Analog and Digital Electronic Circuits
  
  
• Introduction to Embedded Systems
  
  
• Code: The Hidden Language of Computer Hardware and Software
  
  
• The Elements of Computing Systems
  
  
• Foundations of Multithreaded, Parallel and Distributed Programming
  
  
• The Practice of Programming
  
  
• The C programming language
  
  
• The C Companion
  
  
• Expert C Programming
  
  
• C Interfaces and Implementation
  
  
• Data Structures and Program Design in C
  
  
• The Unix Programming Environment
  
  
• Computer Systems: A Programmer's Perspective 3rd edition is 64-bit, 2nd edition is mostly 32-bit and a little 64-bit while 1st edition is all 32-bit.
  
  
• The C++ Programming Language 4th edition
  
  
• Discovering Modern C++
  
  
• C++ Templates: The complete guide
  
  
• Modern C++ design
  
  
• Scientific and Engineering C++
  
  
• Advanced C++ programming styles and idioms
  
  
• Design Patterns
  

There is an updated second edition.

I started with this book and then switched over to learning iphone stuff. Teaches you xcode, cocoa and basic obj-c.

I was very please with Aaron Hillegass's book, Cocoa Programming for Mac OS X

Pick up Aaron Hillegass' book and also look at the Apress series. For online stuff, cocoadevcentral.com is a good place and I'd also recommend the Objective-C Beginner's Guide. There's a ton of resources out there, just keep poking around online.

I've only begun learning iOS and Objective-C, with very little previous coding experience (some work with Visual Basic in high school...Har har). I'm using The Big Nerd Ranch Guide to iPhone Programming and Programming in Objective-C 2.0. Both come pretty highly recommended, and are even suggested for beginners, though both seem geared towards those with some previous coding experience. Either way I haven't had too much trouble yet, so I imagine someone with expertise in another language shouldn't have issues with these books.

Having a bit of experience myself, I was able to loosely follow a tutorial from a book a friend had lent me (possibly this book) and create a basic calculator app in a couple of hours while reading. If you copied their tutorials without trying to understand it at first, you could have a working app quickly, but it would obviously take longer to actually learn the rules behind it.

So you are not a reader? Do you really want to give your CC number to some guy you don't know in another country?

Advanced Programming in the Unix Environment by Stevens Also the best book for everything else.

Yeah, programs doesn't need to know what the speed of your processor is...

Don't you think that microsoft has considered this? If you think my argument is purely semantics i have some good books on the matter that i can refer to

http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639

This one is particularly good

"Created its own problem"? The problem is documented in detail in two Unix operating systems books, as explained in the blog post. We didn't create the problem -- this problem is fundamental to how Unix works, and using Docker doesn't suddenly make it go away.

If you don't believe me, go read Operating Systems Concepts by Silberschatz et al, or Advanced Programming in the UNIX Environment by Stevens et al. Look up what they have to say about PID 1 and zombie processes.

Heck, even Solomon Shykes, founder of Docker inc, recognizes this problem. But it pains me that I have to appeal to authority even though the facts are out there.

Learning C first is a waste of time IMHO. The concepts of C that need to be understood for using the frameworks can be easily learned from a book like Programming in Objective-C.

Now for Cocoa or Cocoa Touch it really only makes sense to get the latest edition of any book related to this topic, as too much has changed over the last couple of years. Even a book from late 2011 would be obsolete in many ways.

Thus I would recommend resorting to online documentation, most notably Apple's Developer Website and start fiddling around with the given examples.

Advanced Programming in the UNIX Environment, 3rd Edition

https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739

Wasn't impressed at all with the dinosaur book. Was more of a book for managers and astronaut architects, not a single point in time did I say "Oh, that's how it was done."

I have this book I needed to buy for a course once:

Operating System Concepts by Abraham Silberschatz

You may want to check out this book: The Linux Programming Interface: A Linux and UNIX System Programming Handbook

This is called "Learn C the Hard Way," but I think a better name is "C Programming for Idiots." Just dive in with the real stuff.

http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?ie=UTF8&qid=1317921424&sr=8-1

http://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=sr_1_1?s=books&ie=UTF8&qid=1317921571&sr=1-1

read this beforehand

https://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/1118063333/

https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X

Start with a language like Python. After that it is easier for you to learn C, because you will know at least the basic programming constructs like If-statements, loops, variables etc.

I would learn C with the book The C Programming Language. It's the standard bible for C, short and to the point, and one of the best technical books ever. A good C knowledge is IMHO necessary and useful, because sooner or later you have to use C libraries or at least fall back to the C interfaces of Mac OS or iPhone OS to do certain things that aren't there in the Objective-C abstraction layers.

After you have a solid C knowledge, you can learn about Object Oriented Programming and Objective-C. Apple has a good introduction to both topics: Introduction to The Objective-C Programming Language.

After you know the language, you can learn about Cocoa in the Cocoa Fundamentals Guide and do your first graphical Cocoa application with Xcode and Interface Builder with the Cocoa Application Tutorial.

Then buy the book Cocoa Programming for Mac OS X by Aaron Hillegass. You will learn to use some of the most important Cocoa classes. After that you can stay with the Apple docs and reference.

When you know Cocoa, you can do your first steps with iPhone development very easily by watching the peepcode.com introduction videos IPHONE VIEW CONTROLLERS PART I and IPHONE VIEW CONTROLLERS PART II - oh, peepcode has even a Objective-C introduction video OBJECTIVE-C FOR RUBYISTS but it's very ruby-centric...