Senior Level Software Engineer Reading List

Read This First

1. Mastery: The Keys to Success and Long-Term Fulfillment
   
   

   Fundamentals
   

   
   

2. Patterns of Enterprise Application Architecture
   
3. Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
   
4. Enterprise Patterns and MDA: Building Better Software with Archetype Patterns and UML
   
5. Systemantics: How Systems Work and Especially How They Fail
   
6. Rework
   
7. Writing Secure Code
   
8. Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries
   
   

   Development Theory
   

   
   

9. Growing Object-Oriented Software, Guided by Tests
   
10. Object-Oriented Analysis and Design with Applications
    
11. Introduction to Functional Programming
    
12. Design Concepts in Programming Languages
    
13. Code Reading: The Open Source Perspective
    
14. Modern Operating Systems
    
15. Extreme Programming Explained: Embrace Change
    
16. The Elements of Computing Systems: Building a Modern Computer from First Principles
    
17. Code: The Hidden Language of Computer Hardware and Software
    
    

    Philosophy of Programming
    

    
    

18. Making Software: What Really Works, and Why We Believe It
    
19. Beautiful Code: Leading Programmers Explain How They Think
    
20. The Elements of Programming Style
    
21. A Discipline of Programming
    
22. The Practice of Programming
    
23. Computer Systems: A Programmer's Perspective
    
24. Object Thinking
    
25. How to Solve It by Computer
    
26. 97 Things Every Programmer Should Know: Collective Wisdom from the Experts
    
    

    Mentality
    

    
    

27. Hackers and Painters: Big Ideas from the Computer Age
    
28. The Intentional Stance
    
29. Things That Make Us Smart: Defending Human Attributes In The Age Of The Machine
    
30. The Back of the Napkin: Solving Problems and Selling Ideas with Pictures
    
31. The Timeless Way of Building
    
32. The Soul Of A New Machine
    
33. WIZARDRY COMPILED
    
34. YOUTH
    
35. Understanding Comics: The Invisible Art
    
    

    Software Engineering Skill Sets
    

    
    

36. Software Tools
    
37. UML Distilled: A Brief Guide to the Standard Object Modeling Language
    
38. Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development
    
39. Practical Parallel Programming
    
40. Past, Present, Parallel: A Survey of Available Parallel Computer Systems
    
41. Mastering Regular Expressions
    
42. Compilers: Principles, Techniques, and Tools
    
43. Computer Graphics: Principles and Practice in C
    
44. Michael Abrash's Graphics Programming Black Book
    
45. The Art of Deception: Controlling the Human Element of Security
    
46. SOA in Practice: The Art of Distributed System Design
    
47. Data Mining: Practical Machine Learning Tools and Techniques
    
48. Data Crunching: Solve Everyday Problems Using Java, Python, and more.
    
    

    Design
    

    
    

49. The Psychology Of Everyday Things
    
50. About Face 3: The Essentials of Interaction Design
    
51. Design for Hackers: Reverse Engineering Beauty
    
52. The Non-Designer's Design Book
    
    

    History
    

    
    

53. Micro-ISV: From Vision to Reality
    
54. Death March
    
55. Showstopper! the Breakneck Race to Create Windows NT and the Next Generation at Microsoft
    
56. The PayPal Wars: Battles with eBay, the Media, the Mafia, and the Rest of Planet Earth
    
57. The Business of Software: What Every Manager, Programmer, and Entrepreneur Must Know to Thrive and Survive in Good Times and Bad
    
58. In the Beginning...was the Command Line
    
    

    Specialist Skills
    

    
    

59. The Art of UNIX Programming
    
60. Advanced Programming in the UNIX Environment
    
61. Programming Windows
    
62. Cocoa Programming for Mac OS X
    
63. Starting Forth: An Introduction to the Forth Language and Operating System for Beginners and Professionals
    
64. lex & yacc
    
65. The TCP/IP Guide: A Comprehensive, Illustrated Internet Protocols Reference
    
66. C Programming Language
    
67. No Bugs!: Delivering Error Free Code in C and C++
    
68. Modern C++ Design: Generic Programming and Design Patterns Applied
    
69. Agile Principles, Patterns, and Practices in C#
    
70. Pragmatic Unit Testing in C# with NUnit
    
    

    DevOps Reading List
    

    
    

71. Time Management for System Administrators: Stop Working Late and Start Working Smart
    
72. The Practice of Cloud System Administration: DevOps and SRE Practices for Web Services
    
73. The Practice of System and Network Administration: DevOps and other Best Practices for Enterprise IT
    
74. Effective DevOps: Building a Culture of Collaboration, Affinity, and Tooling at Scale
    
75. DevOps: A Software Architect's Perspective
    
76. The DevOps Handbook: How to Create World-Class Agility, Reliability, and Security in Technology Organizations
    
77. Site Reliability Engineering: How Google Runs Production Systems
    
78. Cloud Native Java: Designing Resilient Systems with Spring Boot, Spring Cloud, and Cloud Foundry
    
79. Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation
    
80. Migrating Large-Scale Services to the Cloud

> Thanks for your time, my god this was longer than expected.

I suppose in the age of twitter that was a bit of a novel. For us old fogies, that's just a bit more than a post card :)

Introduction to Algorithms is the book for learning everything about algorithms. You'll learn all the standards; how to analyze them (space/time efficiency, Big-O, Big-Theta); and how to prove them; etc.

If you want to learn a great low-level language, the typical things to learn are assembly and C, but I would highly suggest learning Forth. There's tons on the web about it, but the seminal book was Starting Forth. You get all of the low-level detail of assembly, a bit of scaffolding, and you learn to build your higher level language structures as you need them. Great fun, and it's turned out to be very useful through the years, even though I never get to use it in production/release.

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

Sure!

The Physics of Solar Cells by Jenny Nelson is a nice book. Very dense, a little mathy, and assumes some prior knowledege.

This book by Martin Green is the gold standard, though it is probably less accessible than Nelson's and harder to find.

It's probably necessary to have a good grasp of freshman physics, and it would certainly be helpful to understand classical electrodynamics and some solid state physics, which itself requires a little bit of quantum mechanics.

Necessary math for all of this is some calculus, some differential equations, and some linear algebra.

There may be a much friendlier resource out there; I understand if this is a formidable stack.

According to the CP/M wikipedia page, you need the following to run it:

• A computer terminal using the ASCII character set
  
  
• An Intel 8080 (and later the 8085) or Zilog Z80 microprocessor
  
  
• At least 16 kilobytes of RAM (beginning at address 0)
  
  
• A means to bootstrap the first sector of the diskette
  
  
• At least one floppy disk drive
  
  So with the parts list above along with the UART should be enough to meet the requirements. You will need to use banked memory or a similar mechanism (since you need the bootstrap code at address 0, but CP/M needs RAM at address 0 as well). Only problem is the floppy drive, which you should be able to overcome with a Compact Flash card, an CF to IDE converter, and a IDE interface. I haven't tried this myself but I think something like this would work.
  
  If you were interested in writing your own OS, Operating Systems by Woodhull Tanenbaum is a good book on the topic.

Some books on my wishlist (not sure if you're okay with math):

TAOCP

Operating System Principles

Computer and the Brain

Path to the Quantum Computer

Hey now - Slackware 96 is still the Internet's Favorite 32-bit Operating System