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.

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

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

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!

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

Yes, there is a lot of growth for Linux administrators.

I can't speak for the LPIC but you should get The Linux Bible and The Linux Command Line and Shell Scripting Bible and work through those. Then take the RHCSA and RHCE.

The Linux Bible

Linux Command Line and Shell Scripting

I don't know where you're located where junior administration can't lead into auditing or information security but you should build a lab and start building that knowledge and gaining experience. Chris Sanders has great books on the subject and an amazing website.

http://chrissanders.org/

He uses Linux for network monitoring and analysis.

There are also a slew of magazines and podcasts out there to keep you motivated, entertained, and educated. Jupiter Broadcasting is something I really enjoy. They took me from a Linux fan into an enthusiast into a professional. Linux Unplugged, Linux Action Show, TechSnap... Even the quirky BSD guys are awesome.

Linux Format is a great magazine, Admin is good, Linux Journal is hit or miss for me but it hits the spot when I'm looking for something off the wall or a project.

There are also subs on this site that are helpful and fun. /r/linuxadmin is interesting, /r/linuxmasterrace is GOAT, /r/linux is... Linux... /r/gentoo is beardly, /r/archlinux is -- READ THE WIKI.

If you get those books, which I can't recommend enough, start playing with Python too. Don't get Learn Python the Hard Way, get something like Python Crash Course which is significantly better. Your mileage may vary, this is just my opinion.


Good luck! Best thing to do is get a distro and start learning. Read the man pages/wikis, and then post a question. That will help you a lot in the coming days ;)

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

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

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

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'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! ;)

> 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

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.

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

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.

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.

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.

When I started, the most memorable three resources I know I had were the following:

• Bjarne's book - I don't think any C++ developer can truly call themselves even intermediate until they have absorbed at least half the content in the book. I started off with his 3rd edition, which is way less intimidating and shorter, but I subsequently ran through this entire book after it came out. There are no shortcuts on here - you need to read it.
  
• Effective C++ 3rd Edition - I would almost require this one as it prevents any new C++ developer from getting caught in C++ gotchas. You should ideally follow this book up with his 4th edition afterwords. The reason why I recommended the 3rd first is because that book is much more newbie friendly. The 4th edition is targeted towards experienced C++ developers that already have had their feet wet with C++11/14 and want to figure out some best practices. Note the 3rd edition is for C++98 while the 4th is for C++11/14.
  
  After you're done with the two above required books, here are some useful readings:
  
  
• What Every Programmer Should Know About Memory - This is an absolutely essential reading whether or not you've taken any systems courses. It's the foundation of what you will be programming towards (optimizing CPU cache usage).
  
• 1024cores - I believe this guy works/worked at Google at one point, but his site is essential to understanding multi-threaded programming (which is essential in the field). Browse through his site and learn what you can.
  
• Linux Kernel Development - Robert Love (who also works at Google) has probably written the most concise and understandable book on the Linux kernel I've ever read, and I've run through the Daniel Bovet's book and Michael Kirrisk's. For one thing, they're 1,000 and 1,500+ pages, respectively. Secondly, all I've found in those two books that I didn't find in Robert Love's is the implementation details in some areas as well as the details on the scheduler. Robert Love's incredible descriptions on the bottom-half/tasklets were already more than effective for normal understanding. I believe the latter books were more detailed in the networking areas as well, but in that case, you're better off with Understanding Linux Network Internals.
  
  The above readings will probably be a solid 6-12 months to read and absorb assuming you spend a couple hours a day, but I think it'll be well worth it in the long run since this type of stuff sticks with you for a long time. I read the above around 2013, and I can still talk about the CFS/other schedulers, software interrupts, and how the CPU cache works. It'll also make converting to other languages even more of a breeze because you'll know how everything works underneath the hood.

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! :)

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

What OS? Linux, of course. When TPB order everything locked down, you don't want to be caught using a Microsoft OS. -- What distribution? The easy path is Ubuntu, with the Cinnamon UI, or LinuxMint 13, when issued (May 2012).

What IDE? There's lots to choose from. My favorite is "geany".

https://en.wikipedia.org/wiki/Geany

For TCP/IP protocol tutorial. Recently updated by Wright:
Stevens, "TCP/IP Illustrated", 3-volume set.

http://www.amazon.com/TCP-IP-Illustrated-Volume-Set/dp/0201776316

On human interface guidelines relevant to programming:

https://en.wikipedia.org/wiki/Human_interface_guidelines

For GNOME 2, see:

http://library.gnome.org/devel/hig-book/stable/

To develop Linux applications:

You are right. You MUST know how to program in C. When others tell you that object oriented programming is the thing, know that you can do object oriented programming in C. Avoid interpreted languages (Python, Java, and others) as a first programming language. Interpreted languages teach bad habits and hid too much of what's going on from you such that debugging becomes difficult to impossible.

However, if all you intend is "casual programming", the Python will do, if you must. It's just not the best choice first a first language if your intent is to become a "professional programmer". I use Python myself; It works for what I need to do quick and dirty.

Definitive, but for experienced programmers:

http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1335197606&sr=1-1

As a tutorial for someone learning a first programming language and how to program from zero:

Perry, "Absolute Beginner's Guide to C", 2ed.
-- I have not read the book, but the ToC looks reasonable for a beginner.

http://www.amazon.com/Absolute-Beginners-Guide-2nd-Edition/dp/0672305100/ref=sr_1_6?s=books&ie=UTF8&qid=1335197606&sr=1-6

OK, you don't want a full CS curriculum, but some topics in discrete mathematics are mandatory. ... Ack! Having looked over the offerings at Amazon, I believe that Epp, "Discrete Mathematics with Applications" may be the best of the lot, but at $187, it is hard to recommend without knowing your intent and interest. The reason I suggest this title is that it looks focused on application to computer science topics. It covers a number of topics that are NOT covered in many of the other titles, enough so that should you use other texts you will have spent more than the $187 that this title includes. JMHO.

http://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/0495391328/ref=sr_1_1?s=books&ie=UTF8&qid=1335199316&sr=1-1

See also: Sedgwick, "Algorithms" -- You'll probably need it sooner than later.

http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X/ref=sr_1_1?s=books&ie=UTF8&qid=1335200153&sr=1-1

Remember that Linux OS? You are going to need some programming tools, right? If you intend to write GUI applications based on the GTK+ toolkit, then install the package "glade" or "glade-gtk". Installing a glade package will suck in over 100 other packages essential to building a GTK based GUI application. Specifying glade to the package manager is just easier that finding and installing all the other necessary parts by hand.

If you are going to do command line based UI programs, then package "build-essentials" should be adequate.

There are some other things to read:

On how to organize, grow and maintain a Linux software development project: Fogel, "Producing Open Source Software"

http://producingoss.com/

You can read it online here, but buy the book too to help support Fogel. He's gotta eat too.

On the culture of writing Open Source Software:

Raymond, "The Cathedral and the Bazaar"

http://www.catb.org/~esr/writings/cathedral-bazaar/

Linux programming is not like Windows programming.
Read and study ESR's TAOP.

Raymond, "The Art of Unix Programming"

http://www.catb.org/~esr/writings/taoup/html/

You can read it online, free. However, buy a hardcopy too. Raymond has to eat too.

Now to get really technical. What interface do you write to?

Kerrick, "The Linux Programming Interface: A Linux and UNIX System Programming Handbook"

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

Beginning to focus on GNU style programming:

GNU Coding Standards

https://www.gnu.org/prep/standards/

GNU Coding Standards is more than how to and how much to indent a line or how to set braces. You will get into the topic of Make and Autotools. Make is a program to build complex softare and Autotools is about how to build a package for distribution, the package that any Unix flavor can use; it is not focused on any specific distribution. See also: "configure and make"

Enough! There's more, but I have too much time in this already for today.

[edit: typos]

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.

Here are my two recommendations based on what you're starting with:

https://amzn.com/1430249358 - Beginning C# Object Oriented Programming by Dan Clark

It's circa 2013, but that shouldn't matter too much. The point of this book is to get you understanding the fundamentals which haven't changed a bit in a while. I can't speak to the effectiveness of this book, personally (I came from C++, so for me it was more about learning how inheritance patterns in C# differed and this book wouldn't have worked for me), but I've recommended it to other people looking to get a start in programming and it has been well received. The goal with this book is to get to the point where you can read a serious book on C# and this provides that pretty well.

After that, head right over to:

https://amzn.com/1491927062 C# 6.0 in a Nutshell - by Joseph Albahari and Ben Albahari (O'Reilly Press).

I own every edition of the C# in a Nutshell series and have read each (speed reader - lots of skimming/scanning since each edition has a lot of repeat content). I'm a huge fan of the "in a Nutshell" books - the "signal to noise" ratio of these books is very high - they're excellent books for people who prefer/are best at learning via books - think of it as an "AP Course". It'll take you a while to get through (the last guy who successfully completed both took 9 months front to back at about 20 hours a week using a strategy that involved reading the book about 4 times [topic for another post] -- it was for a job, so he had no choice but to learn). When you're done, though, you'll understand a large percentage of C# code and be able to write many different kinds of applications.

From there, it's time to head toward the particular discipline you'll be developing most frequently with (ASP.Net MVC, etc) or target certain areas (multithreading/thread safety is usually a good place to go next if you have no particular target).

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

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.

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/

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.

Hopefully you can find some helpful answers, guidance, or a starting point in these responses.


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.

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!

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.

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.

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.

You need a strong grasp of C programming, I'd recommend:

1: Join the Linux kernel mailing list: http://www.tux.org/lkml/

2: Read a book like this: http://www.amazon.com/Programming-4th-Edition-Developers-Library/dp/0321776410/ref=sr_1_sc_4?ie=UTF8&qid=1415153633&sr=8-4-spell&keywords=Crogramming

3: This is a cool site: http://www.learn-c.org/

Cultural immersion is also important, I would find relevant channels on irc.freenode.net and make friends there where you will find amazing free support from the community.

Once you're a little more comfortable in the language I would start trying to read the kernel source code, or maybe try to fix bugs that are posted about any programs that you are interested in learning more about.

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

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.

Here's my list of the classics:

General Computing

• But How Do It Know? - The Basic Principles of Computers for Everyone
  
  
• The Elements of Computing Systems: Building a Modern Computer from First Principles
  
  
• Code: The Hidden Language of Computer Hardware and Software
  
  
• Gödel, Escher, Bach: An Eternal Golden Braid
  
  Computer Science
  
  
• The New Turing Omnibus: Sixty-Six Excursions in Computer Science
  
  
• Compilers: Principles, Techniques, and Tools, 2nd Edition (aka The Dragon Book)
  
  
• The Art of Computer Programming
  
  
• Algorithms, 4th Edition
  
  
• Introduction to Algorithms, 3rd Edition (aka CLRS)
  
  
• Essential Algorithms: A Practical Approach to Computer Algorithms Using Python and C#, 2nd Edition
  
  
• Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People
  
  
• Structure and Interpretation of Computer Programs, 2nd Edition (aka SICP, available for free on the MIT website)
  
  
• Discrete Mathematics with Applications, 4th Edition
  
  Software Development
  
  
• Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems by Martin Kleppmann
  
  
• Design Patterns: Elements of Reusable Object-Oriented Software (aka The Gang of Four)
  
  
• Think Like a Programmer: An Introduction to Creative Problem Solving
  
  
• The Pragmatic Programmer: your journey to mastery, 20th Anniversary Edition, 2nd Edition
  
  
• The Mythical Man-Month: Essays on Software Engineering
  
  
• Code Complete: A Practical Handbook of Software Construction, 2nd Edition
  
  
• The Design of Everyday Things
  
  
• Clean Code: A Handbook of Agile Software Craftsmanship
  
  
• Programming Pearls, 2nd Edition
  
  
• Soft Skills: The Software Developer's Life Manual
  
  
• Hello, Startup: A Programmer's Guide to Building Products, Technologies, and Teams
  
  
• Hacker's Delight, 2nd Edition
  
  
• Peopleware: Productive Projects and Teams, 3rd Edition
  
  Case Studies
  
  
• The Soul of a New Machine
  
  
• Masters of Doom: How Two Guys Created an Empire and Transformed Pop Culture
  
  
• Hackers: Heroes of the Computer Revolution
  
  
• Where Wizards Stay Up Late: The Origins Of The Internet
  
  
• Fire in the Valley: The Birth and Death of the Personal Computer, 3rd Edition
  
  Employment
  
  
• Cracking the Coding Interview: 189 Programming Questions and Solutions, 6th Edition
  
  
• The Complete Software Developer's Career Guide: How to Learn Programming Languages Quickly, Ace Your Programming Interview, and Land Your Software Developer Dream Job
  
  
• The Self-Taught Programmer: The Definitive Guide to Programming Professionally
  
  
• The Passionate Programmer: Creating a Remarkable Career in Software Development
  
  Language-Specific
  
  C
  
  
• The C Programming Language, 2nd Edition
  
  Python
  
  
• Automate the Boring Stuff with Python: Practical Programming for Total Beginners, 2nd Edition
  
  
• Python Crash Course: A Hands-On, Project-Based Introduction to Programming
  
  
• Python Programming: An Introduction to Computer Science, 3rd Edition
  
  
• Effective Python: 59 Specific Ways to Write Better Python
  
  C#
  
  
• The C# Player's Guide, 3rd Edition
  
  C++
  
  
• The C++ Programming Language, 4th Edition
  
  
• Starting Out with C++: from Control Structures to Objects, 9th Edition
  
  Java
  
  
• Introduction to Java Programming and Data Structures: Comprehensive Version, 11th Edition
  
  
• [Java: A Beginner's Guide](https://www.amazon.com/Java-Beginners-Seventh-Herbert-Schildt/dp/1259589315/, 7th Edition)
  
  
• Java: The Complete Reference, 11th Edition
  
  
• Core Java Volume I - Fundamentals, 11th Edition
  
  
• Starting Out with Java: From Control Structures through Objects, 6th Edition
  
  
• Effective Java, 3rd Edition
  
  Linux Shell Scripts
  
  
• The Linux Command Line: A Complete Introduction, 2nd Edition
  
  
• Wicked Cool Shell Scripts: 101 Scripts for Linux, OS X, and UNIX Systems, 2nd Edition
  
  
• Linux Command Line and Shell Scripting Bible
  
  
• Mastering Linux Shell Scripting
  
  Web Development
  
  
• Learning Web Design: A Beginner's Guide to HTML, CSS, JavaScript, and Web Graphics, 5th Edition
  
  
• Eloquent JavaScript: A Modern Introduction to Programming, 3rd Edition (also available for free on the author's website)
  
  
• JavaScript and JQuery: Interactive Front-End Web Development
  
  
• HTML and CSS: Design and Build Websites
  
  
• You Don't Know JS: Up & Going
  
  Ruby and Rails
  
  
• Ruby on Rails Tutorial: Learn Web Development with Rails, 4th Edition (Note: this book is somewhat out of date compared to the live version on the author's website.)
  
  
• The Well Grounded Rubyist, 3rd Edition
  
  
• Practical Object-Oriented Design in Ruby: An Agile Primer
  
  
• Agile Web Development with Rails 5.1
  
  
• Programming Ruby 1.9 & 2.0: The Pragmatic Programmers' Guide, 4th Edition
  
  
• Eloquent Ruby
  
  Assembly
  
  
• Assembly Language for x86 Processors, 8th Edition

I'd recommend Programming in C for a beginner. It goes through all the basic stuff in great detail with plenty of good exercises, and it's well written and easy to read too.

Honorable mention to Pointers on C, a little more advanced, but definitely the most useful C book imo. Can be hard to find a reasonably priced copy but well worth it if you can.

K&R (The C Programming Language) is oft recommended but I found it impenetrable when I was starting out. There are better options these days for more or less all experience levels.

I recommend you pick an architecture that you can work in and see somewhat immediate results from; x86 is a good idea because it's very well supported and just about every question about it has been answered somewhere. You'll probably be working on a simulator otherwise, in which case you can run into all sorts of other fun problems, and you'll likely end up learning stuff that doesn't apply too terribly well to how things are actually done in the wild.

Dialect-wise: If you're doing standalone assembly or something for use only on Windows/DOS platforms, then NASM or MASM is your best bet. If you want your assembly code to interface more closely with, or be embedded inline within C code in anything remotely resembly a GNU compiler (including GCC, ICC, and Clang, most notably), then GAS is your best bet.

As was mentioned, GAS uses a different syntax from Intel's standard one (different operand orderings, different mnemonics, pretty much everything's different for some fucked-up reason) so you'll see mostly NASM/Intel-like syntax in plaintext (tutorials and the like) on the Web and GAS in source code.

Can't recommend you towards any good resources, although when I was a wee bairn I learned 16-bit x86 assembly from Jeff Duntemann's book (16-bit DOS version, which you can use in DOSBOX or a run of DOS's DEBUG; 32-bit Linux version, which you can use in 32- or 64-bit Linux provided you use the -m32 flag to compile). NASM's manual may still have a decent instruction reference in it (check for older versions, because it was quit handy), and Intel's Software Developer's Manuals are the go-to reference for their backwards-compatible shitheap of an ISA once you're familiar with it.

I just saw you said low on funds, but if you have a birthday or something coming up these two books have been great resources for me, and others that have taken a dive into it.

https://www.amazon.com/Linux-Bible-Christopher-Negus/dp/111821854X

https://www.amazon.com/Linux-Command-Shell-Scripting-Bible/dp/111898384X/ref=pd_sbs_14_img_1?_encoding=UTF8&psc=1&refRID=J9RW2JJ25KF0HEW2DDNK

One thing I'd say is DON'T BE DISCOURAGED. There's a lot to Linux, and it'll feel like you are drinking through a fire hose sometimes with concepts, everyone has been there, and I'm still very much there. In addition to reading a butt load, one thing that helped me take the edge of was getting a box up with something I'd use. My personal pet project back in the day was setting up a redhat instance and run a ventrilo server. It helped me learn things like security, package management, patching, getting real comfortable with things like awk and sed. I didn't expose it to the internet except for a few whitelisted IPs but it kept me learning for a long time, and made it fun.

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

And for the love of God, do not use Unity before you get good grasp on C# syntax and OOP concepts.

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.

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.

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!

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.

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!

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.

Yes, because browsers "run" webpages inside of sandboxes, where performance and security are critical. This is similar to how the kernel runs userspace programs. Think of the DOM and various JavaScript functions as syscalls. Browsers also contain their own memory manager similar to Virtual Memory; except with Garbage Collection. The various obscure file formats browsers have to support (VRML) are like executable formats that kernels support (COFF). Browsers support a variety of network protocols (TFTP, FTP, HTTP 1.0/1.1, Web Sockets and now SPYDY). Browsers also need to support plugins and provide an internal API for them to hook into. Finally, FireFox is 9.23M lines of C++/C/JavaScript which brings it close to Linux's 16M lines of C.

Kernels are really not that mysterious or complex. If your interested in learning about the architecture of the Linux Kernel, checkout Linux Kernel Development by Robert Love.

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.

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

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

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.

> Are the books any good?

It's been years since I looked at them but they used to be mediocre.

Bonus Data! Microsoft Visual C# Step by Step (9th Edition) (Developer Reference) 9th Edition from Microsoft Press has 11 reviews averaging to 3.7 out of 5.

This search for C# on Amazon shows C# books ranked by average customer review. Some of them are too old. I don't know what to recommend.

I find it amusing, though, that C# 6.0 in a Nutshell is 1136 pages long. That's a BIG friggin' nutshell. :)

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.

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.

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.

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!

I like Dave Beazley's book, though it may be a little tough for a noob as it's a real reference. The beginning does have a quick introduction to python, but it doesn't try to teach python. The rest of the book is a reference for many of the library modules.

Another one to consider is Doug Hellmann's book. If you like his online Python module of the week site you'll like the book.

Both of the above books are references to using the library modules. Once you know the base language this is the sort of reference you need. If you are still learning base python then you need some other reference until you are ready for books like the two above. The nice thing about Amazon is that you can download a free e-book sample before buying, though it's probably wise to do a final check of the paper version before buying as an e-book can be very different from the paper version (usually worse, but who knows). The Hellmann e-book is particularly bad in this respect.

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!

In short, the answer is virtual memory and the protected mode flat model that the past generations of CPU architecture and operating systems have been using.

As you may know, programs are never given full, direct access to the RAM banks; the operating system abstracts this layer away from them in the form of virtual memory. Virtual memory is basically a system whereby you can map physical memory addresses to non-physical ones the OS controls and can readily re-arrange. Thanks to virtual memory the OS can trick an application into thinking it has way more RAM than it actually has and this also enables swapping processes out to disk when the system is running out of memory because there are too many processes being run at the same time. As I pointed out before, since virtual memory is fully managed by the kernel, it can move out chunks of a program's address space to disk, a process known as "paging".

Now, back in the DOS era, virtual memory followed the real mode segmented model, which, in very simple terms meant that, even though processes could be shuffled back and forth between RAM and disk, there were no safeguards in place to prevent a process from messing up another process' memory space via a dodgy pointer pointing to a memory address beyond the scope of the faulty process.

One of the major goals of the successor to this virtual memory model, "protected mode flat model" was to allow the kernel to create a completely isolated address space for the processes it spawns and stopping a rogue program from altering other processes like before. Whenever such an attempt is made, a "segmentation fault" (SIGSEV) or "general protection fault" is raised by the kernel, which in the case of Linux, will prompt the kernel to swiftly kill the offending process.

In practical terms, this means your application won't be able to reach beyond the virtual memory address space it has been allocated (unless it's a kernel-space process, like a kernel subsystem or device driver) and can in no way communicate with other processes by reading or writing memory that belongs to them. In order to accomplish that, you'll need to make use of inter-process communication (IPC) techniques like Unix sockets, pipes, RPC, etc.

This is by no means an in-depth or 100% accurate explanation though. If you've got any follow-up questions I'm more than happy to answer them.

As for the literature, pretty much any textbook about operating system architecture will cover virtual memory to a great extent. I can recommend Operating Systems: Internals and Design Principles and Modern Operating Systems.

Here are a few more books that touch upon the topic of virtual memory:

Assembly Language Step-by-Step: Programming with Linux covers the topic of virtual memory and the different models that have evolved over time over its first few chapters.

The Linux Programming Interface: A Linux and UNIX System Programming Handbook covers this subject (and many, many more) from a Linux systems programmer perspective.

What Makes It Page?: The Windows 7 (x64) Virtual Memory Manager, in case you're interested in learning how Windows does it.

EDIT: added IPC info

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

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!

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.

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.

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.

Three books I have been using:

The Definitive Guide to How Computers Do Math

Web page here: http://www.diycalculator.com/

Assembly Language Step-by-Step: Programming with Linux

Hacking: The Art of Exploitation, 2nd Edition

The first uses a virtual machine running on Windows, with 5 registers, 65K of virtual memory, a debugger, and will give you a good basic understanding of what is going on. The second book uses Intel X86 on Linux, and gives a solid foundation of the most used instructions. The third book is just good.

Other favorites of mine include "The Art of Debugging" by Norm Matloff (google for his excellent web page) and "Professional Assembly Language" by Richard Blum.

Have fun!

I'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!

apply, and be up front about about your java background. honestly, java and c# share a ton of similarities. Brush up on a book (this may not be a bad idea anyway as c# and .net jobs are available about anywhere).
Worst case scenario, you learn something new (and can now compare and contrast c# and java) and get some interview experience.

edit: I really enjoyed C# 6.0 in a nutshell. There are a ton of more economic resources out there. Most employers outside of the really big tech companies care more about your passion for learning and your soft skills than if you can deliver a perfect solution on a whiteboard.

> However, I've never done any development work for it. At my company, we will start to have some Linux work for our embedded processors. Before that work comes along, I'd like to start getting an appreciation for it and getting myself a good grounding in it.

Is it really going to be actual kernel work like writing drivers?
Most embedded platforms are vendor supported anyways
so there’s little to do kernel side unless your company has
very specific requirements.

If instead you’re going to do low-level userspace things,
the best resources for learning kernel APIs are the [Kerrisk]
(https://www.amazon.com/dp/1593272200) as a reference
and a LWN subscription to stay up to date.

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.

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

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.

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!

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

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?

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.

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.

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!

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.

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!

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.
  

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

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.

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.

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

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

I really love this book, has tons of great info in it. Might be able to find it online somewhere.

https://www.amazon.com/Linux-Command-Shell-Scripting-Bible/dp/111898384X/ref=pd_lpo_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=KDKCH1GWS30M5R9G2Z3A

Otherwise, come up with a simple task you want to accomplish, and try and break it down into small steps. Then do some reading on basic bash commands and try and piece it together from there!

>shell prompt

If you have money, this one is a good option

These two are good and available for free, I suggest you start with them.

> administration

This one is the best.

I just got c# 6.0 in a nutshell for Christmas, as I'm trying to get my .NET game up. I'm only about 200 pages in but I find it pretty effective. My first introduction to C# was through this video tutorial, which is good but not even a fraction of what you learn with the book.

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!

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.

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

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

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.

C# in a nutshell is a good reference to learn the ins and outs of the language without muddying up the concepts with opinionated frameworks and patterns.

https://www.amazon.com/C-6-0-Nutshell-Definitive-Reference/dp/1491927062

Learning the languages capabilities is only half the battle, and once you have the syntax down you really want to supplement that with a book that teaches you how to write C# as the language designers intended. The following is a little old but written by some of the original members of the .net team and fairly timeless

https://www.amazon.com/Framework-Design-Guidelines-Conventions-Development-ebook/dp/B0017SWPNO

I've worked with several great C++ developers who thought they knew C# but we're really still just writing C++ without ever really learning to embrace the language. Don't be like that

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.

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

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.

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!

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.

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.

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

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.

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

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.

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

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

Programming in C by Stephen G. Kochan

Hands down the best beginner book

A new version (4th) was just released this past August.

Any experienced programmer will tell you so. The K&R book is an excellent resource however Programming in C is much better suited for an absolute beginner.

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.

1. Objective-C because there were no good books on Swift at the time, and I wanted to learn to code for iOS first.
   
   
2. I'm best with Obj-C, rather than Java and PHP, likely because I learned it first. I'm not sure if everyone falls in love with the first language they learn but I sure did.
   
   
3. I mentioned this elsewhere, but I'll paste that comment below (note: I may have linked the wrong version for one of the books).
   
   
4. Up!
   >
   > 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.

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

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.

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

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.

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.

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.

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.

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

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.

Check out this Crash Course series, it's quite informative: https://www.youtube.com/watch?v=O5nskjZ_GoI.

If you want to go deeper, check out some of the free Computer Architecture courses on the Internets.

Alternatively, if you want to be a Linux/Windows power user, there are some good books out there, like this.

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
  

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

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.

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

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.

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.

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.

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

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