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 do have a textbook called "C: A modern approach" by King, but like I said before, I think it focuses more on the coding aspect.

Most books that focus on C are going to be about learning the language. If you want to learn low level stuff, you need to find books that focus on them (and they'll usually incidentally use C). The language itself is quite small and minimalistic in what it can do. Most heavy handed things like networking and GUIs require interaction with the OS.

Eg, if you wanted to do networking, you could use the Windows API or the POSIX socket API (POSIX being the standards that *nix systems follow -- and certain versions of Windows). Or you could use a higher level library like curl for cross platform support (and a wealth of nicer features).

>Can somebody please guide me on where to start?

Firstly, as much of a linux fanboy I am, I do want to make sure you know that you don't need to use Linux for any of the other things you wanted to learn (low-level programming, command lines, networking, etc). In fact, my OS class mostly used Linux, but we started out with a project using Windows threads (I guess the prof wanted us to see the difference from POSIX threading).

All that said, I do think Linux is something you'd want to learn and that a lot of low level things just seem more natural in Linux. But I'm biased. Linux fanboy, remember?

I'd start with downloading a Linux OS. Doesn't really matter which. I'd recommend going with Ubuntu. It's the most popular, easiest to find help with, and seems to be what most web servers are running, to boot. You can play around with the GUI for a bit if you want. It won't feel that different. Modern OSes sort of converged into the same high level ideas.

My favourite book for getting into the command line ever so slightly touching the low level aspects of OSes is Mark Sobel's A Practical Guide to Linux Commands, Editors, and Shell Programming. It will include some basic knowledge of Linux, but mostly focuses on the command line. But this is very useful because not only is the command line very practical to learn, but you'll end up learning a lot about Linux in the process (eg, by learning how everything is a file, how pipes work, etc). And arguably the command line a super big part of Linux, anyway. It makes sense as the first step.

Now, for the next step, you need to know C very well. So finish with your class, first. Read ahead if you have to. Yes, you already know if statements and functions and all, but do you understand pointers well? How about function pointers and void pointers? Do you understand how C's arrays work and the usage of pointer arithmetic? How about how arguments are passed to functions and when you'd want to pass a pointer to a function instead? As a rough skill testing question, you should implement a linked list for arbitrary data types with functions such as prepending, appending, concatenating lists, searching, removing, and iterating through the list. Make sure that your list can be allocated and freed correctly (no memory leaks).

Anyway, the next step is to learn OSes. Now, I said OSes and not Linux, because the Linux OS is a bit constrained if you want to learn low level programming (which would include a knowledge of what OSes in general do, and alternatives to OSes like Linux). But never fear, pretty much any OS book will heavily use Linux as an example of how things work and consequently explain a great deal of Linux internals. I can't recommend a class because mine was a regular university class, but Tanenbaum's Modern Operating Systems is a good book on the subject.

In particular, you can expect an OS class to not merely be focused on building an OS yourself (my class worked on aspects of OS101 to implement portions of our own OS), but also on utilizing low level aspects of existing OSes. Eg, as mentioned, my class involved working with Linux threading, as well as processes. We later implemented the syscalls for fork, join, etc ourselves, which was a fascinating exercise. Nothing gets you to understand how Linux creates processes like doing it yourself.

Do note, however, that I had taken a class on computer architecture (I found Computer Organization and Design a good book there, although note that I never did any of the excerises in the book, which seem to be heavily criticized in the reviews). It certainly helps in understand OSes. It's basically as low as you can go with programming (and a bit lower, entering the domain of computer engineering). I cannot say for sure if it's absolutely necessary. I would recommend it first, but it's probably skippable if you're not interested (personally, I found it phenomenally interesting).

For learning networking, Beej's book is well written. You don't need to know OSes before this or anything.

I started from scratch on the formal CS side, with an emphasis on program analysis, and taught myself the following starting from 2007. If you're in the United States, I recommend BookFinder to save money buying these things used.

On the CS side:

• Basic automata/formal languages/Turing machines; Sipser is recommended here.
  
• Basic programming language theory; I used University of Washington CSE P505 online video lectures and materials and can recommend it.
  
• Formal semantics; Semantics with Applications is good.
  
• Compilers. You'll need several resources for this; my personal favorites for an introductory text are Appel's ML book or Programming Language Pragmatics, and Muchnick is mandatory for an advanced understanding. All of the graph theory that you need for this type of work should be covered in books such as these.
  
• Algorithms. I used several books; for a beginner's treatment I recommend Dasgupta, Papadimitriou, and Vazirani; for an intermediate treatment I recommend MIT's 6.046J on Open CourseWare; for an advanced treatment, I liked Algorithmics for Hard Problems.
  
  On the math side, I was advantaged in that I did my undergraduate degree in the subject. Here's what I can recommend, given five years' worth of hindsight studying program analysis:
  
  
• You run into abstract algebra a lot in program analysis as well as in cryptography, so it's best to begin with a solid foundation along those lines. There's a lot of debate as to what the best text is. If you're never touched the subject before, Gallian is very approachable, if not as deep and rigorous as something like Dummit and Foote.
  
• Order theory is everywhere in program analysis. Introduction to Lattices and Order is the standard (read at least the first two chapters; the more you read, the better), but I recently picked up Lattices and Ordered Algebraic Structures and am enjoying it.
  
• Complexity theory. Arora and Barak is recommended.
  
• Formal logic is also everywhere. For this, I recommend the first few chapters in The Calculus of Computation (this is an excellent book; read the whole thing).
  
• Computability, undecidability, etc. Not entirely separate from previous entries, but read something that treats e.g. Goedel's theorems, for instance The Undecidable.
  
• Decision procedures. Read Decision Procedures.
  
• Program analysis, the "accessible" variety. Read the BitBlaze publications starting from the beginning, followed by the BAP publications. Start with these two: TaintCheck and All You Ever Wanted to Know About Dynamic Taint Analysis and Forward Symbolic Execution. (BitBlaze and BAP are available in source code form, too -- in OCaml though, so you'll want to learn that as well.) David Brumley's Ph.D. thesis is an excellent read, as is David Molnar's and Sean Heelan's. This paper is a nice introduction to software model checking. After that, look through the archives of the RE reddit for papers on the "more applied" side of things.
  
• Program analysis, the "serious" variety. Principles of Program Analysis is an excellent book, but you'll find it very difficult even if you understand all of the above. Similarly, Cousot's MIT lecture course is great but largely unapproachable to the beginner. I highly recommend Value-Range Analysis of C Programs, which is a rare and thorough glimpse into the development of an extremely sophisticated static analyzer. Although this book is heavily mathematical, it's substantially less insane than Principles of Program Analysis. I also found Gogul Balakrishnan's Ph.D. thesis, Johannes Kinder's Ph.D. thesis, Mila Dalla Preda's Ph.D. thesis, Antoine Mine's Ph.D. thesis, and Davidson Rodrigo Boccardo's Ph.D. thesis useful.
  
• If you've gotten to this point, you'll probably begin to develop a very selective taste for program analysis literature: in particular, if it does not have a lot of mathematics (actual math, not just simple concepts formalized), you might decide that it is unlikely to contain a lasting and valuable contribution. At this point, read papers from CAV, SAS, and VMCAI. Some of my favorite researchers are the Z3 team, Mila Dalla Preda, Joerg Brauer, Andy King, Axel Simon, Roberto Giacobazzi, and Patrick Cousot. Although I've tried to lay out a reasonable course of study hereinbefore regarding the mathematics you need to understand this kind of material, around this point in the course you'll find that the creature we're dealing with here is an octopus whose tentacles spread in every direction. In particular, you can expect to encounter topology, category theory, tropical geometry, numerical mathematics, and many other disciplines. Program analysis is multi-disciplinary and has a hard time keeping itself shoehorned in one or two corners of mathematics.
  
• After several years of wading through program analysis, you start to understand that there must be some connection between theorem-prover based methods and abstract interpretation, since after all, they both can be applied statically and can potentially produce similar information. But what is the connection? Recent publications by Vijay D'Silva et al (1, 2, 3, 4, 5) and a few others (1 2 3 4) have begun to plough this territory.
  
• I'm not an expert at cryptography, so my advice is basically worthless on the subject. However, I've been enjoying the Stanford online cryptography class, and I liked Understanding Cryptography too. Handbook of Applied Cryptography is often recommended by people who are smarter than I am, and I recently picked up Introduction to Modern Cryptography but haven't yet read it.
  
  Final bit of advice: you'll notice that I heavily stuck to textbooks and Ph.D. theses in the above list. I find that jumping straight into the research literature without a foundational grounding is perhaps the most ill-advised mistake one can make intellectually. To whatever extent that what you're interested in is systematized -- that is, covered in a textbook or thesis already, you should read it before digging into the research literature. Otherwise, you'll be the proverbial blind man with the elephant, groping around in the dark, getting bits and pieces of the picture without understanding how it all forms a cohesive whole. I made that mistake and it cost me a lot of time; don't do the same.

I've been playing around with writing a programming language and compiler in my spare time for a while now (shameless plug: http://eigenstate.org/myrddin.html; source: http://git.eigenstate.org/git/ori/mc.git). Lots of fun, and it can be as shallow or as deep as you want it to be.

Where are you with the calculator? Have you got a handle on tokenizing and parsing? Are you intending to use tools like lex and yacc, or do you want to do a recursive descent parser by hand? (Neither option is too hard; hand written is far easier to comprehend, but it doesn't give you any correctness guarantees)

The tutorials I'd suggest depend on exactly where you are and what you're trying to do. As far as books, the three that I would go with are, in order:

For basic recursive descent parsing:

• Huh, will have to dig around a bit, maybe write something up.
  
  For general compiler knowledge, here are the books that I'd recommend in order:
  
  
• Modern Compiler Implementation in ML: https://www.cs.princeton.edu/~appel/modern/ml/
  
  This is a great book. It's fairly modern, written reasonably well, covers most topics you'll need. Just stick to the ML version, because it's pretty clear that Appel wrote first in that language, and then did pretty poor translations to C and Java for the other books.
  
  
  
• Programming Language Pragmatics: https://www.cs.rochester.edu/~scott/pragmatics/
  
  Another good compiler textbook. Covers language design, a large number of various programming models, and so on. Too light on optimization, IMO.
  
  
• Compilers: Principles, Techniques, and Tools, AKA "The Dragon Book": http://www.amazon.com/Compilers-Principles-Techniques-Alfred-Aho/dp/0201100886
  
  This is the classic compiler book. It's one of the oldest, and it focuses a bit heavily on parsing, but it covers a large number of topics. It's, in my opinion, dense but very well written and surprisingly easy to follow.
  
  
• Compiler Construction: http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf
  
  This book's main claim to fame is that it's a decent overview, but it's available online for free.
  
  
• How to build a compiler: http://compilers.iecc.com/crenshaw/
  
  This is the fastest zero-to-compiler book out there, but it's ridiculously simplistic, and doesn't lead to any next steps. It just tells you how to generate terrible machine code. But it's hands on.
  
  And for later,
  
  
• Advanced Compiler Design and Implementation: http://www.amazon.com/Advanced-Compiler-Design-Implementation-Muchnick/dp/1558603204
  
  More a collection of papers on optimization than a textbook, it's a good summary of relatively advanced techniques to explore once you have a compiler that works and does what you want, and generates tolerably good code.

The Stanford Algorithm book is complete overkill in my opinion do NOT read that book. That's insane. Read it when you've been doing programming for a while and have a grasp of how it even applies.

Here's my list, it's a "wanna be a decent junior" list:

• Computer Science Distilled
  
• Java/ C# / PHP/ JS (pick one)
  
• Do some Programming Challenges
  
• SQL
  
• Maybe build a small web app. Don't worry about structure so much, just build something simple.
  
• Applying UML: and Patterns: An Introduction to Object Oriented Anaysis and Design Iterative Development
  
• Head First Design Patterns
  
• Clean Architecture
  
• Refactoring: Improving the Design of Existing Code
  
• If you're interested in Web
  
• Soft Skills: Power of Habit , A Mind for Numbers , Productivity Project
  
  ​
  
  Reasoning: So, the first book is to give you a sense of all that's out there. It's short and sweet and primes you for what's ahead. It helps you understand most of the basic industry buzz words and whatnot. It answers a lot of unknown unknowns for a newbie.
  
  Next is just a list languages off the top of my head. But you can pick anything, seriously it's not a big deal. I did put Java first because that's the most popular and you'll like find a mountain of resources.
  
  Then after some focused practice, I suggest grabbing some SQL. You don't need to be an expert but you gotta know about DBs to some degree.
  
  Then I put an analysis book that's OOP focused. The nifty thing about that book, is it breaks into design patterns nicely with some very simple design patters to introduce you to design patterns and GRASP.
  
  Then I put in a legit Design Patterns book that explains and explores design patterns and principles associated with many of them.
  
  Now that you know how code is structured, you're ready for a conversation about Architecture. Clean architecture is a simple primer on the topic. Nothing too crazy, just preps you for the idea of architecture and dealing with it.
  
  Finally, refactoring is great for working devs. Often your early work will be focused on working with legacy code. Then knowing how to deal with those problems can be helpful.
  
  FINAL NOTE: Read the soft skills books first.
  
  The reason for reading the soft skills books first is it helps develop a mental framework for learning all the stuff.
  
  Good luck! I get this isn't strictly computer science and it's likely focused more toward Software Development. But I hope it helps. If it doesn't. My apologies.

Agree. It depends on what you want to know, and how much you're willing to commit to learning. It's a big world. Code is a nice book if you want a very very simple explanation of the basics of bits and bytes and logic gates. It might be a good place to start, though it's intended for a non-technical audience and you may find it a little TOO simple. A proper digital systems book will go in to much more detail about digital logic (AND gates, flip-flops etc.). You might be surprised just how easy to learn the fundamentals are. I learned from Tocci which I found to be excellent, but that was a long time ago and I'm sure there's many other good ones around.

That's pretty low level digit circuits though. If you are really serious about learning computer architecture, I'd highly recommend Patterson and Hennssey . It covers the guts of how processors execute instructions, pipelining, caches, virtual memory and more.

If you're more interested in specific, modern technologies... then obviously Wikipedia, or good tech review sites. Especially reviews that focus on major new architectures. I remember reading lots of good in depth stuff about Intel's Nehalem architecture back when it was new, or nvidia's Fermi. There's a wealth of information out there about CUDA and GPU computing which may give you a sense of how GPUs are so different to CPUs. Also when I first started learning many years ago, I loved my copy of Upgrading and Repairing PCs , great for a less technical, more hobbyist perspective.

Lastly, ask questions! For example, you ask about DDR vs GDDR. Deep inside the memory chips themselves, actually not a great deal of difference. But the interface between the memory and the processor are quite different, they're designed for very different purposes. I'm simplifying here but CPUs have relatively low levels of parallism, they tend to operate on small units of memory (say a single value) at a time, they have quite unpredictable access patterns so low latency is essential, and the cores often work tightly together so coherency has to be maintained. With GPUs, they have a very predictable access pattern, so you can load much larger chunks at a time, latency is less important since you can easily keep your processors busy while memory is streamed in, and the GPUs many many tiny processors for the most part all work on separate words of memory, so coherence usually does not need to be maintained and they have much less need for caches.

The "L" (Level) naming for caches is quite simple. Memory that is closer to the core is faster to access. Generally each core has it's own L1 and L2, with L2 being slightly slower but there's more of it, and all cores share an L3, slower still but way more of it. Memory on the cpu is made out of transistors and is super fast but also takes up alot of space. Look how big the L3 is (here)[http://www.anandtech.com/show/8426/the-intel-haswell-e-cpu-review-core-i7-5960x-i7-5930k-i7-5820k-tested] and that's just 20MB. external ram is obviously much slower, but it is made out of capacitors and has much higher densities.

Now you've doubled your memory usage. That is not necessary.

Computers do things at a set speed. If you want fast code, you have to tell the computer to do fewer things. That means you need to be efficient: get a lot done with fewer instructions and less waste. If you just minimize the wasted effort you'll end up in a good spot.

That's going to be hard to do if you don't know what instructions actually are and don't understand basic computer architecture.

It's also why "threading will make it go faster" is so fallacious. Threading doesn't make things faster, per se, it just attempts to minimize latency by using more resources while often introducing overhead that decreases total system throughput. Using 8 cores to get a 6x speed up might seem like a good idea, until you realize you're introducing latency to every other process and your total CPU time is 33% higher. This also introduces all sorts of weird cache effects which can end up violating assumptions relevant to performance in both your code and other code running on the same system. Unless you need to minimize latency, focus on writing the best single threaded code you can.

Do not write performance sensitive code, such as image processing primitives, in Python. Write it in modern C++. You can call your compiled C++ function from Python. You can reasonably expect to see an order of magnitude improvement just from doing this. It also opens all sorts of doors when it comes to performance tuning.

Allocating and deallocating memory (I'm not very good at Python but I think that's what you're doing with temp=[]) takes time. You know what takes zero time? Declaring an array with a certain fixed size, up front. Alternatively you can use a std::vector<> and immediately .reserve() the size you need. (Don't use .resize() unless you need it.) At the very least you don't need to clear and reappend to your buffer.

You do not need to sort the elements within the 3x3 window. You need to find their median. nth_element() can do this. As can a heap of 5 elements (for a 3x3 filter) you conditionally insert into. (That is the solution to a classic interview question, actually.)

It is unlikely that .sort() is optimized for your specific case. With so few elements it is likely that something like insertion sort, or even bubble sort, will be faster.

Your current formulation can not take advantage of SIMD, which is leaving a lot of performance on the table. Since images are often single channel, 8 bit resolution and common vector sizes are 128 bits you could be leaving 16x performance on the table by not exploiting SIMD instructions. If you don't know what SIMD is you need to go fix that.

(Nitpick: "filter_size // 2" is correct, but why not just do a bitshift? I'm not sure about Python's ability to make the conversion for you.)

You are biasing the filter near the border of the image. By inserting zeros into your buffer instead of only looking at valid pixels you are biasing your filter towards darker values at the borders. You could do some tricky things to find the median of the valid pixels only, but I would recommend just not having the filter be defined there. In computer vision maximizing reliability is often a core focus, so it is often better to just let the output be smaller than the input. Zero-bias error is a really, really nice property to have: don't accidentally lose it over something so trivial.

I'm not that savvy with Python but I'm pretty sure that in "for j in range(len(data[0])):" the len() is being evaluated in each iteration of the "i" loop around it. Compute this once and cache it.

You have multiple if statements in your inner loop. You are guaranteeing that you will get multiple branch mispredictions here. Even if you somehow avoided them, you're checking for an edge condition on every single pixel.

There are a couple of ways to avoid your boundary conditions. The most obvious is to just zero pad your data. This is what most people do, and it can be the right thing. But it makes you use more memory and can introduce an image copy. What I like to do is explicitly write the boundary conditions, then go into a loop for the bulk of the image. This increases lines of code but you don't have to compromise on performance.

I had to solve a similar problem recently. It was single channel, uint16_t data from a very noisy sensor on a system with 128 bit vector width. I needed a 5x5 median filter and decided to use the median of medians approach. Median of medians gives a result whose position is guaranteed to be within 10% of the position of the median in a sorted list. That is, for a list L of size S which has been sorted to give a list K it will return an element between K[0.4*S] and K[0.6*S]. Here is how I implemented it:

The image width size was already a multiple of the vector width. I created a buffer of size 5*row_width. I treated this as a cyclic buffer of 5 rows (such that row n would be evicted once I added row n+5 to it). I was provided a separate output buffer.

Before I tell you the next part, realize that C=A<B, where A and B are SIMD vectors, will fill each element of C with all 0 bits or all 1 bits depending on if the result is true or false. This is useful as a bit mask. Perhaps you don't have a vector min instruction and need to synthesize C=min(A,B) like so:

M = A < B;
C = (A & M) | (B & (~M));

I first prefill the buffer with 5 rows which have had horizontal median filtering applied. Here is how I do that filtering on each row:

I used 5 overlapping vector loads (unaligned loads are performant on this system) to create 5 vectors of 8 elements each (128/16=8). I then run a parallel median finding network on each (look up "sorting networks"). StackOverflow has some example code:

template<class V>
inline V median(const V &a, const V &b, const V &c)
{
return max(min(a,b),min(c,max(a,b)));
}

template<class V>
inline V median(const V &a, const V &b, const V &c, const V &d, const V &e)
{
V f=max(min(a,b),min(c,d)); // discards lowest from first 4
V g=min(max(a,b),max(c,d)); // discards biggest from first 4
return median(e,f,g);
}

Of course if you are lucky enough to have a med3 instruction you should use that instead of the 3 argument median function.

I write the result to the buffer and skip down 8 elements, repeating this process until I fill a full row into the buffer.

After the initial 5 are filled into the circular buffer, I am then ready to output a row of final results. I do this 8 at a time by loading from each of the 5 rows in the circular buffer and running that through the same median finding network. The result is written back in place to the input image. This introduces no RAW hazard because I am reading from 2 rows below it.

I then add another row to the buffer, and then immediately compute one more row of final results (as in the previous paragraph). This continues until I run out of output rows.

Of course I also tweaked how the loops were unrolled.

(Actually, I interleaved these horizontal and vertical median finding operations so I could trade some register pressure for better performance by dodging some vector loads. I only bothered because I was already used to writing ASM on this platform.)

This runs at full resolution, high frame rate on a single (<1 GHz) core while leaving plenty of time for the rest of processing of that frame before the next one comes in. It's runtime is within a few percent of optimal. I haven't timed your code but I'd be willing to bet it is more than 100x slower.

I suggest learning at least the basics of computer architecture if you want to write performant code. Tools like Godbolt are indispensable. (See also.) You're likely not getting within an order of magnitude of optimal if you stick with Python.

I think the approach you've described seems totally reasonable.

​

Setting aside the aspect of one vs multiple repos, there is a spectrum of component isolation. So for example, at one end would be a single terraform configuration (main.tf) that defines ALL your resources -- the lambdas, the queues, the dbs, etc. This has some nice properties -- for example less bookkeeping, avoidance of deployment ordering issues, and no need for a mechanism to share references to resources (such as the shared tfvar file you mentioned). And it is possible with this setup to deploy only specific resources by using the -target flag when doing terraform apply.

​

But to your point, every time you deploy a lambda you're putting at risk all these other resources if something goes sideways.

​

At the other end of the spectrum, with highly isolated components, split across several tf configs / state files, you mitigate that risk but it creates other issues.

​

You mentioned the one about needing to share resource names across tf configurations...for that, IMO, the remote_state data source would be a better mechanism to share outputs across tf configurations.

​

Another problem specific to lambda subscriptions that you might run into is that you have to define each lambda's event source, and the way you do this varies confusingly (cause AWS, not cause tf). Example: you'd create an aws_lambda_event_source_mapping to have the lambda subscribe to an SQS queue, and an aws_s3_bucket_notification to have it subscribe to bucket events. If components are split across configurations (and repos)...which tf config owns those mappings? The first I'd argue makes sense with the lambda, but the second might make more sense alongside the bucket.

​

So you have to share ARNs or names or whatever across tf configurations, but then you also have to decide how to split up these resources that are kind of on the fence, and this might create dependency ordering problems, like, you have to deploy the SQS queue before lambda #1, but lambda #2 before the S3 bucket notification, etc.

​

Zooming out: for this kind of architecture I think it's useful to group together stateful and stateless resources. TF is great for deploying the stateful resources like buckets, queues, dbs. There are arguably better tools for deploying the stateless resources, i.e. the lambda functions, such as the serverless framework or other language-specific frameworks. (Where tf is really painful is setting up API Gateways, lolsob, and serverless makes that part easy.)

​

But you still need to deal with this issue of communicating resource identifiers across the stateful/stateless resource definitions. And something like serverless framework provides a nice clean abstraction over "lambda events," but that abstraction becomes quite leaky when you're not able to do something like subscribe a lambda to an existing bucket that was created by tf because Cloudformation (which serverless uses under the hood) is like "nope, I don't control that bucket, and the subscription is owned by the bucket -- can't do it."

​

Sorry for the longwinded answer :D

​

TLDR: lambda subscriptions are confusing, and I would probably do something like what you're advocating but consider putting it all into separate terraform configs in the same repo if it makes sense, and use the remote_state data source. And if the lambda deployments / APIGW stuff becomes painful, swap in a better tool for that part at that time.

​

Terraform: up and running is a really great book and chapter 3 in particular has more advice that might be useful for your situation!

I'm not so sure exactly what you want with your question, so this answer will be broader than it needs to.

First, it's interesting for you to understand that these are implementation aspects. The C language itself doesn't care about the stack or the heap. It talks about storage duration categories like automatic, allocated, static, or thread local. Where these go in real memory is an implementation aspect.

This is an interesting read on the topic: http://ramblings.implicit.net/posts/2014/4/21/there-is-no-stack (btw, the whole blog is very good).

If you want to know more details about the C language, check the ##c irc channel @ irc.freenode.com wiki => http://www.iso-9899.info/wiki/

The description of the storage duration categories are pretty helpful. For example, you should use automatic storage when you want scoping to handle it (it = the duration of the storage for the variable) for you. If you need the storage throughout your program, you can make it static. If you don't know very much about it, but you'll learn more at runtime, consider allocated. I've never used c11 to actually comment on the specifics of thread local. Of course, this is a pretty general broad vague description.

K&R2 has plenty of exercises, many of which involve dealing with memory. It won't be in terms of implementation concepts like stack and heap. It'll be in terms of C's mechanisms for dealing with memory.

With all that out of the way, you can learn about implementation aspects through many different places. And I'm only mentioning this because you said "stack" and "heap", which seems to me is because you have your head around implementation concepts instead of C language semantics.

Anyway, you have options here.

• An OS book may tell you how an OS might deal with memory management.
  
• A computer architecture book might tell you about memory as well. They commonly talk about caches. You'll learn different ways memory can be dealt with (at the computer architecture level) and how that might affect a program's performance.
  
• There is a book specifically about all kinds of memory: http://www.amazon.com/Memory-Systems-Cache-DRAM-Disk-ebook/dp/B00BXETR06/
  
• A compiler design book (specially an optimizing compiler design book) will talk about code generation and optimization which are relevant for memory access.
  
• What Every Programmer Should Know About Memory - http://www.akkadia.org/drepper/cpumemory.pdf
  
• Books on C, and also on C++, tend to cover this quite often.
  
• Books on program optimization can also cover this.
  
  Notice that all of these documents talk about more than what you're asking for. I don't know any book and/or document which only talks about what you want. It's also a pretty general topic, because the useful question lurking behind the scenes is how to effectively use memory, which is pretty broad. You can look at:
  
  
• related algorithms;
  
• related data structures;
  
• relevant implementation aspects;
  
• behavior of other systems you're making use of (including libraries and the OS);
  
• ... <anything that will help> ...
  
  And also, "effectively use memory" depends on a criteria: what is it that you consider to be "effectively"?
  
  In the end, there is a lot to your question.

Self-taught software engineer checking in to add on to this.

Everything u/TOM_BRADYS_PET_GOAT said is true.

I'll add a few specific resources:

Computer science fundamentals are really scary and overwhelming if you're self-taught. I'd highly recommend reading The Imposter's Handbook to get started with this topic. You'll want more in-depth material afterwards on each of the various subtopics, but this book is absolutely fantastic as a (surprisingly deep) introduction to all the concepts that's framed specifically to get self-taught programmers up to speed.

After you're familiar with the concepts at a conceptual level, and it's time to just get down to dedicated practice, Cracking the Coding Interview will be an invaluable resource. This book exists for the sole purpose of helping people become better at the types of questions most commonly asked during coding interviews. It's not just a list of a bunch of questions with solutions, it actually explains the theory in-depth, provides drill and smaller practice questions, as well as questions designed to emulate specific interview scenarios at real tech companies like Google, Microsoft, Amazon, etc. It'll even talk about the interview process at those companies outside of just the questions and theory behind them.

As a more general resource that you'll reach for repeatedly throughout your career, I'd recommend The Complete Software Developer's Career Guide. This book covers everything. How to learn, how to interview, how to negotiate salary, how to ask for raises, how to network, how to speak at conferences and prepare talks, how to build your personal brand, how to go into business for yourself if you want, etc. and that's just scratching the surface of what's covered in that book. I did't even buy this book until I was 10 years into my career and it's still very insightful.

And lets not forget, being a good developer isn't just a matter of making things that work, it's a matter of writing code that readable, extensible, and a pleasure for other developers to work on. So to this end, I'd recommend any developer read both Clean Code and Clean Architecture: A Craftsman's Guide to Software Structure and Design

What field do you want to specialize in? Embedded? Web? Mobile?

The best way to learn is by practicing, but if you want more of an abstract, design level read, there are lots of options.

I'm have a web background, so here's three that I've read recently as examples.

I enjoyed this book on microservice design and I think everyone who uses OOP should at least familiarize themselves with the common OOP design patterns.

If you are into JavaScript, Eloquent JavaScript is my go-to for a good mix of summary/detail of the language. It's well written, and comes with fun exercises at the end of each chapter to help solidify your understanding of each concept.

I'm sure there are other great books, but these are some of my favorites so far.

-How long after completing the camp did it take for you to get hired?
Within 10 days.
-Who do you work for?
~16 person consulting company in the bay.
-Did you have any prior coding experience before enrolling at the camp?
Yes full year of self study and some classes in high school and college.
-Are you happy with your current earnings?
I was untill I realized the cost of living where I am and how much Uncle Sam takes.
-Do employers consider the camps as sufficient to warrant upward mobility potential?
There is another person in my company that also went to my code camp. Our camp (app academy) discouraging revealing our participation in the camp till late in the hiring process.
-Best strategy to get accepted?
Apply.
What kind of students are they looking for? Can I, with my limited background become successful?
In my experience you can have the ability to think in that way or not.

What sort of students are most successful both during the camp and then in the job search following the camp?
The ones you would expect.
-Recommendations for pre-study?
Keep trying different tools until you really find something that works.

A great book is http://www.amazon.com/But-How-Know-Principles-Computers/dp/0615303765.
If i was gonna put forward one online resource it would be http://www.tutorialspoint.com/.

If you have a little time try some of the assembler stuff.

One final tip. There will be a time (or thousands) where you will be staring at some concept and drawing a blank. It may feel like nothing is happening. It may well be that lots of things are and you just gotta process the concepts.

Good luck.

There's a lot of Raspberry Pi kits on Amazon that come with wires, a breadboard, some LEDs, and other electronic components. The CanaKit Ultimate is one such kit that's a good price for what it contains. In addition to the Pi kit get him some books with interesting projects.

• Getting Started with the Raspberry Pi
  
• Raspberry Pi Projects for the Evil Genius
  
• Raspberry Pi Projects
  
  These are all pretty good books and have interesting projects. If your son is actually interested in engineering don't let him just stick XBMC or RetroPi on the thing and call it a day. While those projects might be interesting in their own right you're not really learning much if you're just assembling a video player or video game emulator.
  
  If he puts together some interesting projects with the Pi get him a Radio Shack gift card for his birthday. They're trying to get back to being the electronic hobby retailer of choice so they're carrying Pis, Arduinos, and stocking more electronic components.
  
  What's nice about a good kit is a lot of the components will be useful in other types of projects. Breadboards and good wires work just as well on an Arduino as they do on a Raspberry Pi.

I had this same question about a year ago (I have been coding asp.net since 2003) and have read various books and video courses. I feel that learning architecture is not the same as learning to code. Converting a string to an int there is a few ways to do it but essentially there is a right way to do it. Software design and Architecture is more of an art form taking into account many factors and so to learning it is somewhat of a journey, combining new narrative to your conscious reality.




For me video does not lend itself well to this sort of learning process. Reading the way you do when studying philosophy works much better. So the process of reading a chapter of a book, taking the time to think about it, hypothesizing how you would incorporate the architecture into your current project and questioning if you really need it before proceeding to the next chapter works really well.





Architetecting Applications for the Enterprice is great, they thoroughly go through the thought process involved in choosing an architecture, be it CQRS, DDD, Event Sourcing or Transaction script. It does feel a little dated and I would like to see a 3rd edition but still very good basis.




There is some good books at .NET Application Architecture page. The Microservices & Docker one is good, specifically the chapter on Tackling Business Complexity in a Microservice with DDD and CQRS Patterns. I like how they provide links for futher readying.

I would suggest that the carlh programming guides is not a bad idea then!

I would heavily suggest learning C well - this is a language that was designed to stay close to the hardware while being portable, and is a very small language. So, buy a copy of the K&R Book, ever C programmer has one.

Then, Patterson's book is a tome for computer engineering. It'll show you assembly, all the way down to NAND gates.

I would suggest you start by watching and working through Berkeley's CS61C course. It's the logically second course in CS, and after a quick overview of C it dives into the machine itself. Website here, videos here. Also, Dan Garcia is an excellent lecturer.

Once you have all the machine details down, you'll probably feel hampered by your actual program wizardry. This is where you start looking into algorithms and data structures. Your go-to guide here is probably Cormen's Introduction to Algorithms since it handles both data structures and algorithms. It's definitely more of a theoretical/CS-ey book, so if this is not what you want, then Head First Java will teach you a new language (and learning more languages is one of the best ways to grow as a programmer!) and also do many data structures. In fact, you can get both those books and have the light side and the serious side of programming books.

At this point you should be well equipped to go off in whatever direction you want with programming. Start contributing to open source projects! Find things that interest you and try to solve problems! Being a part of the programming community will be your biggest aid in both learning programming and starting to make money through it. People pay for programmers that they know can deliver, and success in the open source world means a lot, and you don't need to go to school for it to get to this point!

Lastly, many CS/programming folks hang out on IRC. If you have questions, find the appropriate IRCS channels and go talk to people. Good luck and welcome to programming!

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

Basically any SRE advice for a normal service but replace/compliment HAproxy / nginx / ingress controller / ELB with the Tor daemon / OnionBalance.

I run Ablative Hosting and we have a few people who value uptime over anonymity etc and so we follow the usual processes for keeping stuff online.

Have multiples of everything (especially stuff that doesn't keep state), ensure you have monitoring of everything from connections, memory pressure, open files, free RAM etc etc.

Just think of the Tor daemon onion service as just a TCP reverse proxy, with load-balancing capability and then follow any other advice when it comes to building reliable infrastructure;

• https://www.amazon.co.uk/Site-Reliability-Engineering-Production-Systems/dp/149192912X/
  
• https://www.amazon.co.uk/Infrastructure-Code-Managing-Servers-Cloud/dp/1491924357/
  
• https://www.amazon.co.uk/Architecting-Scale-Lee-Atchinson/dp/1491943394/
  
• https://www.amazon.co.uk/Building-Microservices-Sam-Newman/dp/1491950358/
  
• https://www.amazon.co.uk/Practical-Monitoring-Mike-Julian/dp/1491957352/
  
• https://www.amazon.co.uk/Cloud-Native-Infrastructure-Justin-Garrison/dp/1491984309/
  
• https://www.amazon.co.uk/Designing-Distributed-Systems-Brendan-Burns/dp/1491983647/
  
• https://www.amazon.co.uk/Databases-at-Scale-Operations-Engineering/dp/1491925949/
  
  
  Once you've got to grips with running a reliable service then you can start layering your Onion reverse proxy / load balancing on top.
  
  
• Isolate your daemons from the clearnet (clearnet example; CloudFlare 'Access' suggests you only allow CloudFlare's IPs through your firewall guaranteeing that only traffic scrubbed by them reaches your servers)
  
• Configure Onionbalance (clearnet example; using keepalive-d / CARP / F5 LTMs to have redundancy for the ingress controller)
  
• Harden your software Unlike the clearnet examples of security you'll want to ensure that your software can't be 'tricked' into making a call to a hostile server (e.g. "Please fetch and attach content at this URL") - you can do this with tricks like Ablative's "QuadHop" setup or simply ensure that your software doesn't have such functionality.
  
  
  All of this aside, check /u/alecmuffett's "Onions that don't suck" repo for examples that are both well setup and stable.
  
  
  TL;DR; Tor is just a TCP reverse proxy with load balancer capabilities go learn some DevOps dodads
  
  Edit: As per Alec's comment - clarify that Tor is technically a reverse proxy with load-balancing capabilities rather than a straight up TCP load balancer.

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

Frameworks like Spring and JPA/Hibernate are used in professional software development, and it is important to know them, but they won't teach you proper ways to architect your software. They are only tools, not substitutes for understanding and judgment.

I would suggest stepping back and learn patterns like Clean Architectures. This will help you understand the principles of software architecture, which is more important than Spring or JPA/Hibernate.

There are plenty of books on this subject. My favorites are Growing Object Oriented Software Guides by Tests, Agile Patterns, Practices and Principles in C# (the book has very little to do with Agile), Clean Code, Clean Architecture, Patterns of Enterprise Application Architecture.

Martin Fowler's website has a lot of good stuff about all architectural topics, from the stuff you're asking about, to microservices and big data.

Uncle Bob has a lot of videos on YouTube that are well worth a watch, like this one. Skip past the first five minutes or so unless you want a physics lesson, too.

As someone else mentioned, the Hennessy and Patterson Computer Architecture: A Quantitative Approach, and the Patterson and Hennessy Computer Organization and Design are the de facto standards (I used both in my Comp. Eng. undergrad) and are really fantastic books (the latter being more "software" oriented so to speak).

They are not EE textbooks (as far as I know) but they are text books nonetheless. A great book I found that is slightly dated but gives a simplified review of many processors is Inside the Machine: An Illustrated Introduction to Microprocessors and Computer Architecture which is less technical but I enjoyed it very much all the same. It is NOT a textbook, and I highly, highly recommend it.

Hope that helps!

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

For architecture/systems people (my area):

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

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

The Dinosaur book for OSes.

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

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

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


And as a side note:

For AI, Russell and Norvig is required reading.

For type systems, Pierce is awesome.

Sounds like what you're interested in is computer architecture. This is the study of how a computer system (whether it's chip level or system level) is organized and designed from a higher-level abstraction (usually at the register-transfer level or above). There are plenty of good resources on this, including many books (this one comes to mind). Not knowing your background, I can't say if this would be much of a stretch for you. I would say prior to jumping to this level you should have an idea of basic MOS logic design, sequential and combinational logic as well as some background in delays and timing.

Your best bet is probably to find a good old book on amazon or ebay and read to your hearts content. Feel free to PM me if you have any questions (I design microprocessors for a living).

I wouldn't worry about it too much unless it shows up as a hotspot in a profile. Mature compilers these days are pretty good about optimizing loops and applying small tricks like conditional moves to make some things branchless.

Still, the Agner Fog manuals are a pretty good place to start for learning about some of these things. And a good introductory text on computer architecture such as Hennessy and Patterson can be helpful too.

It seems that most introductory texts focus on parsing. However, in my experience, the dragon book does a good job on introductory code generation. Appel's Tiger Book had good information as well. As a heads up, the C and Java versions of the same book are done as an afterthought, and you can tell that the code was translated after the fact. Stick with the ML version.

For optimization algorithms, I've heard good (And bad) things about Muchhnik: Advanced Compiler Design and Implementation.

However, I've had better luck just reading various papers. If there's a specific part of code generation and emission, I can point you to plenty of good papers.

POSA books by Buschmann are considered to be the textbooky, Knuth/SICP level stuff from when I studied and are architecture equivalent to the GoF's design thing, but as a consequence they're also huge on OOP. The Fowler Book is even more preachy and OOPy but many things are still relevant. The third would be Uncle Bob's Clean Architecture (sorry for cryptic refs, am on mobile, just Google the refs you'll find them.

On the systems design front one should learn ESB and SOA as they are patterns still relevant in this microservices world but most books on the subject are often tied to particular tech (and its often wrong tech like IBM or Oracle or MS proprietary, untraslateable/untransferable stuff). I've heard good things about Thomas Erl books [1].

I've recently read Sam Newman book on Microservices and while it does have a lot of zeitgeist in it at least it's current zeitgeist and the book is decent.

Edits:

• On keyboard now, added links.
  
• [1] Arcitura, Thomas Erl's company has informative (if a bit ugly) websites on both classical SOA patterns and Microservice patterns. Again, it's buzzwordy, preachy, enterprisey CIO-talk but if you cut through it there are some good overviews of various systems design patterns there and are a quick way to ingest the concepts before dedicating your time to these huge tomes.
  
• The mentioned books have aged well in general but some of the ideas they propose haven't aged that well so I'd like to dedicate a few bullet points to those:
  
  • MVC in particular, has lately fallen out of grace as UI pattern and has become delegated to the backend as data-presentation pattern (i.e. how you design, say, JSON API backends wrt DB access and transforming to JSON), whereas front-end UI has migrated to MOVE pattern which, in terms of GoF speek, mostly relates to MVC by replacing MVC's core Observer pattern with a Reactive programming Observable.
    
  • Active Record ORMs (think Hibernate) have fallen from grace and are becoming replaced with SQL building DSLs like Linq or ORMs with SQL builders below them. DTOs have also given way to either Monad-ic data access objects or swung back to the pre-AR/pre-DTO concept of Data Gateways (more common with Linq-style DSLs).
    
  • Reactive design in combination with Message Queuing has become more and more the method of choice for managing distributed state in SOAs.

Heh, that's a loaded phrase because it people haven't agreed on what it means.

So I agree with both the other posters in that it can include the stack but usually implies a deeper design understanding.

To me, it doesn't make much sense to ask about a rails app's architecture without going into the tech stack precisely because 1) rails apps have the same basic architecture (MVC) 2) the rest of the stack is actually part of the application. Do you use MySQL or Postges or something else? How many rails servers do you have? How many database servers are there and how are they replicated? Etc etc.

However, when you're talking about apps that don't have a given, accepted base design then it's really important to know how it's designed.

I'm going to use the phrase design and architecture interchangeably here, but one could argue they're slightly different.

The architecture of an app influences the "non-functional" characteristics it embodies (also called quality attributes). Furthermore, and more importantly, the architecture itself is (or should be) influenced by the desired non-functional characteristics.

What do I mean by non-functional characteristics? Stuff like:

• Performance
  
• Security
  
• Modifiability
  
• Modular
  
• Testability
  
• etc.
  
  If you think about it, these things are difficult and expensive to change down the road. If you want to add security to an app that's highly modular, you will have a lot of work due to the high amount of decoupling throughout the app. Or imagine trying to add performance to a highly modifiable app. Modifiability usually implies low coupling between parts which also, usually, impacts performance.
  
  So when you think about the architecture of an app, it's how the larger parts are put together to express these non-fuctionals. This can get down to the level of design patterns like MVC (modifiability) and dependency injection (testability) but it starts at a higher level where you look at things like Java packages instead of classes, as an example.
  
  There are a number of books on amazon about this but here are 2 (I've read the first, but not the second):
  
• Software Architecture in Practice
  
• Clean Architecture

While cringing at the 2.0 meme just as much as anyone, I have to recommend my favorite technical devops book right now, which actually has "devops 2.0" in the title:

http://www.amazon.com/dp/152391744X/

It's written by a stellar engineer, for engineers... focused on the technical challenges in implementing devops, rather than hand-waving about culture and vague ideas. All substance, no fluff. Marvelously well written. Opinionated, in the good way (i.e. takes a stand on things and explains his reasoning, leaving you free to disagree).

My only concern is that it's so specific to the technologies of 2016 that - when the current edition inevitably becomes outdated in a year or three - the author will break my heart by declining to put in the work to make an updated version.

Not a magic bullet but these helped me:

• Study the structure of big popular open source projects like lodash or JQuery that have been around for awhile, learn how they structure and organize their code and borrow from it.
  
  
• A book like Clean Architecture might help too.
  
  
• Understand how JavaScript works under the hood and computers in general so you have a better understanding of the whole system, this involves learning low level documentation.
  
  
• Get really good with OOP.
  
  
• Code->Refactor->Code->Refactor, apply and reiterate all the stuff you've learned and see if it works.
  
  Disclaimer: I'm a pretty terrible programmer, but I used to be a lot worse.

Not sure if it's quite what you're looking for but Computer Organization & Design - The HW/SW Interface is a fantastic book on processor architecture and uses the MIPS design as an example through the entire text including good stuff on MIPS assembly programming. The link is for the latest edition (fourth) but if you want to go cheaper the third edition is still available. I used (and still use, about to tutor a course on CompArch) the third edition and it's one of the most useful texts I have ever owned.

Whenever I get an email about a new programming Humble Bundle, I hop over to Reddit to see if anyone else thinks it's worth buying. In this case, Reddit has failed me, because no one has shared their opinions. All is not lost, however, for I can share mine!

These are probably the most commonly recommended DevOps books:

• The Phoenix Project - written in the form of a novel to teach DevOps principles. (I've read it. It's awesome.)
  
• The DevOps Handbook - a non-fiction book from the authors of The Phoenix Project. (I've started it.)
  
• Site Reliability Engineering - "SRE" is more or less Google's term for DevOps. This book is more or less how Google does DevOps. (I've not read it. It's available online for free.)
  
• Accelerate: The Science of Lean Software and DevOps - Martin Fowler calls this the best programming book of this year. (I've not read it.)
  
• The Site Reliability Workbook - a sequel of sorts to Site Reliability Engineering. Probably less popular than the others I just listed. (I've not read it.)
  
  The Site Reliability Workbook is the only one of these that's included in this bundle. So the first question I ask myself regarding this bundle is, "Do I want to spend the time and money on this bundle's books, or should I spend that on one of the highly recommended books instead?" (Personally, I'm going with the latter.)
  
  Otherwise, most of the books here are technology-specific, so the second question is, "Do I want to learn any of these specific technologies now, and are e-books a good way of doing it?" (Personally, my answer is no.)
  
  Depending on how you answer the first two questions, the last question is, "Are the non-technology-specific books worth getting?" To answer that, here are Amazon links to the non-technology-specific books, for reviews and sales rankings:
  
  
• The Site Reliability Workbook
  
• Designing Distributed Systems
  
• Database Reliability Engineering
  
• Seeking SRE
  
• Cloud Native Infrastructure
  
• Practical Monitoring
  
• Effective DevOps
  

>How do you all approach designing a solution like this assuming you will not be able to acquire an existing application?

I'll ignore the whole DB selection thing, because this is the real question that you need answered (and will eliminate the need for the DB thing)


My approach would be: focus on solving the clients problem as fast and cheap as possible. Some principles to follow:

1. Forget the whole scaling DB thing. Build the simplest thing that solves the problem the client has NOW.
   
2. Show it to the client. Have the client use it. Get feedback. Don't skip this, it is important.
   
3. Build using architecture and design techniques that will allow you to change the system as you and your client learn more about the problem at hand - you all gonna be surprised by how wrong you were at first.
   
4. Repeat steps 1-3 for as long this app lives.
   
   I basically just described to you - in a super simplified way - the agile/lean way of building software.
   
   >I am willing to put in the time and effort to learn what I need to learn here -- I just need some guidance!
   
   Here are some book recommendations:
   
   Lean Software Development: An Agile Toolkit
   
   Clean Architecture
   
   Continuous Delivery
   
   
   I hope it helps. Feel free to reach out to me if you want to discuss this further.

I've pretty much done it all, but am kinda dumb, so I stick with the easy stuff :) As for the OS loop...that pretty much everything there is to an OS. I briefly attended an OS design classn(I'd already read this book on my own and dropped it early on. Anyway, the prof who had a ph.d. in OR and OS said on the first day of the class that there haven't been any significant changes to operating systems since 1955 as far as basic architectures go.

I'm basically a software engineer too mostly in the scientific fields for process and system design. Some of the software is, or was at the time, some of the most complex software written. The application programming is the complex part @ > 99.5% of SLOC. The OS just manages the tasks and keeps them safe from one another and handles IPC. Anyway, being intimate with the hardware makes this all almost trivial...that's what hardware is supposed to do.

This is as good a place to start as any. https://www.youtube.com/watch?v=wgdBVIX9ifA

This video was helpful too: https://www.youtube.com/watch?v=e0E6po7tG-8&t=533s

This book is pretty good https://www.amazon.ca/Building-Microservices-Designing-Fine-Grained-Systems/dp/1491950358/ref=sr_1_1?ie=UTF8&qid=1549050596&sr=8-1&keywords=microservices (updated version coming out in august)

Just going from a bunch of hardware to the point where you can input machine code to be executed is a vast topic in itself (and something I don't have knowledge of). Once you can input machine language and have it execute though, I at least have an idea.

You can use machine code to write an assembler, which is a lot of work but not particularly complex.

You can use an assembler to write a compiler (good luck with this one, I'm in compiler design right now and it's a mind blow).

You can use a compiler to write pong.

There are many topics that you can really get acquainted with by just wandering the web. I don't think this is one of them. Once you get it you can really go some complex places, so what you're likely to find online is either too simple, or too complex for the understanding you seek. With dedication a book can probably help you, but if you can make nice with a teacher--auditing a computer organization/assembly language class will really open your eyes to what is going on in there.

Take a look at the course listing at a local college and e-mail the teacher, see if they'll let you audit their class.

This was my textbook for that class, it's decent. Maybe you can find an early edition for cheap:
http://www.amazon.com/Computer-Organization-Design-Fourth-Architecture/dp/0123744938/ref=sr_1_2?ie=UTF8&qid=1302110540&sr=8-2-spell

Not a direct answer for your question, but I recently started reading JavaScript Application Design: A Build First Approach. What I've read is pretty sound and seem like you are the target audience.

The framework in the book is Backbone.js so you won't really get the reactive / shadow-dom stuff that React gives you, but you will have a nice stepping stone to get there.

I would strongly recommend reading this book

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

It should be mandatory reading in all CS and SE degrees IMO.

It will not answer your specific question, but it will provide you with the tools and knowledge to understand how best to approach the problem and ensure your architect and design is well though through and draws on the learnings of those who have come before us.

For the very tragically beginning, you can find the Mac 101 section of the Apple website. Judging by the rest of your post, I'd say most of that is probably pretty elementary for you.

http://hints.macworld.com/ is a great site that has helpful threads on everything from super basics to coding. Along those lines, I'd highly recommend getting The Missing Manual for the appropriate OS version you are on.

Going to a private, but non-profit institution, its cool.

(as a matter of fact, a friend has friends that go to bent state university and after comparing physics hw found that, well our curriculum is much harder, I guess their intro final had a "draw a line to match the term to its definition" type thing)

Anywho, one of our compsci upper level courses is based on this book http://www.amazon.com/Computer-Organization-Design-Fourth-Architecture/dp/0123744938/ref=la_B000APBUAE_1_2?s=books&ie=UTF8&qid=1406428553&sr=1-2 It goes through and explains computer architecture for an actual cpu, I don't recall how easy it is to read however. (if you buy it and it makes no sense, the intro book we use was called, "an invitation to computer science", but get an adition or two back from current if you buy)

Finally you can a bunch of info here http://ocw.mit.edu/index.htm

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

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

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

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

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

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

I guess it depends on how far along you are with Go. I used the following:

"The Go Programming Language" from Addison-Wesley, one of the authors Kernighan, co-authored the "C Programming Language" book. I'm kinda a programming language theory nerd, so I loved it. https://www.amazon.com/Programming-Language-Addison-Wesley-Professional-Computing/dp/0134190440/

I really got a lot out of "Go in Practice" from Manning Publications, especially liked the Concurrency + Concurrency Patterns chapters.

https://www.amazon.com/Go-Practice-Techniques-Matt-Butcher/dp/1633430073/

Since we almost always need some web programming these days, I used "Web Development with Go" for learning some basics and more advanced Go web programming. The code from the book is in github here: https://github.com/Apress/web-dev-w-go. It was good to get started with some APIs in the Go ecosystem.

Next I'm going to start on GUI development with go from Packt: https://www.packtpub.com/application-development/hands-gui-application-development-go

I've also been going through the O'Reilly learning path for Go from Rachel Roumeliotis. https://learning.oreilly.com/videos/learning-path-go/9781491958100/

Some others:

Profiling Go applications: https://www.integralist.co.uk/posts/profiling-go/

I always love the Java/JavaScript/Groovy/Ruby/Python "puzzlers" talks, check out the go puzzlers here: https://talks.godoc.org/github.com/davecheney/presentations/gopher-puzzlers.slide#1

What is your programming background? Do you have any experience in other languages/frameworks?

I haven't used the book you mentioned, but these have been pretty helpful (listed in order of brain-melting complexity):

1. https://www.amazon.com/Microsoft-Visual-Step-Developer-Reference/dp/1509307761/ref=pd_lpo_sbs_14_t_1?_encoding=UTF8&psc=1&refRID=WBZV8Q8BWT8APSVY7YPY
   
   
2. https://www.amazon.com/Adaptive-Code-via-principles-Developer/dp/0735683204/ref=sr_1_43?s=books&ie=UTF8&qid=1540568110&sr=1-43&keywords=C%23
   
   
3. https://www.amazon.com/gp/product/0735685355/ref=oh_aui_search_detailpage?ie=UTF8&psc=1

https://www.amazon.com/DevOps-2-0-Toolkit-Containerized-Microservices/dp/152391744X/ref=sr_1_1?ie=UTF8&qid=1475019854&sr=8-1&keywords=devops+2.0

A great book to get an good techinal overview.
Also r/Devops is a good source for articles and questions

If you're interested in learning a surprising amount about this without needing heavy technical background, might I recommend a fantastic book, But How Do It Know?

This book, even though it says it's specific to .NET, is a great, very recent (published months ago) book about architecting enterprise solutions and is applicable to both JEE and .NET (Two most common enterprise platforms). I read it at my work's book club over the last couple months, and it's a great modern read.

Here is an interesting video where they build a cpu up from the transistor level.

The CPU is only a theoretical one called a "Scott CPU", which was designed by John Scott, who is the author of the book, But How Do It Know?, which is an amazingly straight-forward, easy-to-digest book about computing.

I would recommend it as it was the first thing I read that gave me a deep understanding of computers on an abstract level. It completely demystified them and got me well on my way to programming.

Edit: The video doesn't go down to the transistor level, just goes over each component of a CPU. The book does go down to the transistor level, however, and again, I would highly recommend it.

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.

If you are looking for a very easy to read introduction to how computers work, I can recommend the book "But How Do It Know?". Strange title, but book is great. https://www.amazon.com/But-How-Know-Principles-Computers/dp/0615303765

> Writing an interpreter is an order of magnitude easier for a beginner, especially if they write it in a high level language like Scheme, OCaml or Haskell.

Depends on your target language. If you're compiling to a reasonably high level language (like C or ActionScript) and don't care much about optimization, they're basically the same thing. Instead of maintaining a stack of environments and evaluating to a value, you maintain a stack of symbol tables and evaluate to a program fragment in the target language.

If you need to do instruction selection, calculate branch offsets, or do any sort of optimization, it gets more complicated. But you can still find nearly everything you need between The Dragon Book, Steve Muchnik's Advanced Compiler Design and Implementation, and Appel's Modern Compiler Implementation in ML.

> A good tutorial, if you know Haskell

There's also ArcLite, which implements a Lisp in JavaScript.

Also note that it's possible to blur the lines between compiler and interpreter significantly. For example, one of the exercises in SICP splits the evaluator into one pass to analyze it into closures that do whatever needs to be done with the environment, and then a second pass that actually evaluates that function with the provided environment.

Another trick you can do is to depend on the data structures of the host language for some of your processing. For example, variable lookup in ArcLite is implemented in C. How? Each activation record is a JavaScript object, and then the __proto__ property is used as the static link to knit them together. So when the interpreter goes to look up a variable, it's just a hash lookup, and then the JavaScript runtime automatically consults that activation record's prototype if it fails, exactly as if it were looking up a normal JavaScript variable.

The good news is that MIPS is possibly the most straightforward assembly language to code or read. Compared to x86, it's a dream.

If your class is computer architecture related, you will probably be learning from Hennessy and Patterson, which is an excellent book covering hardware and software.

If you want to learn MIPS from a software perspective, check out the classic See MIPS Run.

For designing programming languages, my favorites are

• Types and Programming Languages by Pierce
  
• Practical Foundations for Programming Languages by Harper
  
• The Formal Semantics of Programming Languages by Winskel. For the domain theory and information systems perspective.
  
  If you only get one then go with Pierce. But If you want to get serious about semantics, then Winskel is the way to go.
  
  On the implementation side my favorites are
  
  
• The Dragon Book -- this is the most popular book
  
• Muchnick for the more involved low level optimizations.
  
• Compiling with Continuations by Appel for compiling a functional language.

I recommend you grab this book, I used it in the university and gives a pretty good explanation of how computers work.

That being said, you would need input from material physicist, electronic engineers, chemists, and a bunch of other professionals to really understand how a computer really works. It is a complex machine, and building one combines knowledge from many many disciplines.

Have you seen the MIPS WikiBooks site?

It's not complete, but after a cursory inspection it looks as though it may be useful for beginners.

What textbook is your class using? I believe that the textbook my course assigned (though I may or may not be able to recommend it as I may or may not have ever read it...) was this one.

Clean Code: Clean Code

Clean Architecture: Clean Arch

​

Just picked these two up myself.. not sure if its what you are looking for, but seem to be very valuable for software design as a whole.

Don't give up just yet, keep looking.
Do you have a portfolio? if not try to work on a project of your own so you can have something to show.
And if you are considering improving your java skills try work with libraries like:

• [Dagger2] (https://github.com/google/dagger)
  
• [RxJava] (https://github.com/ReactiveX/RxJava)
  
• [Retrofit] (https://github.com/square/retrofit)
  
• [Architecture Components] (https://developer.android.com/topic/libraries/architecture/index.html)
  
• Kotlin
  
  With spare time I would also recommend you to read:
  
  
• [Clean Architecture] (https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164)
  
• [Head Frist - Design Patterns] (https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_5?s=books&ie=UTF8&qid=1510076882&sr=1-5&keywords=Design+patterns)
  
• [The Pragmatic Programmer] (https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?s=books&ie=UTF8&qid=1510076924&sr=1-1&keywords=the+pragmatic+programmer)
  

Thanks for your advice. The O'reilly book you mentioned is this one? (Building-Microservices-Sam-Newman). And could you send me some material that you like please? (blog posts included).

I have this one and it is actually great for beginners. Good for learning both Python and the GPIO hardware of the Pi.

Also if you're willing to spend a small amount of money to help I really found this book (https://www.amazon.co.uk/Raspberry-Pi-Projects-Sean-McManus/dp/1118555430/ref=sr_1_10?ie=UTF8&qid=1484694825&sr=8-10&keywords=Raspberry+pi++book) and the Raspberry Pi itself to be of immense help when trying to learn Python, especially when it came to things like embedded software in the board and the AI side of some of the wee games you came make

I highly recommend Structured Computer Organization by Andrew Tanenbaum. It is a great book for beginners

OOP is a very general concept and it doesn't go further than the SOLID principles. As for the how this actually gets done is somewhat of an opinion and open to interpretation. I'm a fan of this book....

Clean Architecture A Craftsman's Guide to Software Structure and Design

It has very strong opinions and because of that it gives a consistent message and direction. It should by no means be the only opinion or book you take in to account (learn from as many people as you can). But it's a very good start.

Clean Architecture, for sure.

Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series) https://www.amazon.com/dp/0134494164/ref=cm_sw_r_cp_apa_i_yJ83Db51V9ZZS

Highly endorsed, first book I read out of school:

Code Complete - Steve McConnell


Bonus, engineers at my office were just given this book as recommended reading:

Clean Architecture - Robert C. Martin

There are some good C# project examples implementing clean architecture in ASP.NET Core (although the architecture itself could be applied to WPF and other kind of apps).

Have a look at this talk: https://www.youtube.com/watch?v=_lwCVE_XgqI

GitHub repository from the talk here: https://github.com/JasonGT/NorthwindTraders (I'd prefer this one)

​

Another example: https://github.com/ardalis/CleanArchitecture

​

Additionally, if you really want to understand the subject this is an obligatory read: https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

I had never heard of But How Do It Know?, thank you for bringing it to my attention. From a related link, another title The Elements of Computing Systems: Building a Modern Computer from First Principles got good reviews as well.

Pick up these books:

• Domain Driven Design
  
  
• Patterns of Enterprise Application Architecture - even if you don't do "enterprisey" work it's still a good read with interesting patterns/use cases.
  
  
• Clean Code
  
  
• Clean Architecture
  
  Just remember that the goal of a good architecture is to provide value, but maintain high quality of code that is easy to maintain and change. Separation of concerns , loose coupling, testability, maintainability and scalability are major points to look out for .

Yes, this is good books

​

I can recommend https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 this books instead Sedgwick

Or if you go further https://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043/ref=sr_1_1?crid=3KIIUSO0OCYLD&keywords=donald+knuth&qid=1566900852&s=books&sprefix=donald+kn%2Cstripbooks-intl-ship%2C369&sr=1-1

Also see this https://www.amazon.com/Structured-Computer-Organization-Andrew-Tanenbaum/dp/0132916525/ref=sr_1_5?crid=2PZADWCTIJ5EM&keywords=tanenbaum&qid=1566900893&s=books&sprefix=tanen%2Cstripbooks-intl-ship%2C263&sr=1-5

If you're in the downtown campus you'll do Python for COMP 1510. The Burnaby campus will be doing Java for COMP 1510.

You should spend time going over HTML, CSS, and Javascript. You'll need Java for certain. You should use w3schools.com to get a good grasp over basic concepts.

One other thing that may help is getting some design books from amazon or as a pdf online to get down coding conventions and ways to think about coding

You'll find that you'll need to test your code in the coding classes and writing code to be testable is a critical skill in school and when you work in the industry.

• Clean Architecture: A Craftsman's Guide to Software Structure and Design by Robert C. Martin

Just want to add a couple of things:

1. Despite the significant practical and theoretical challenges mentioned by the other commenters, it is amazing that compilers nonetheless can parallelize some code in specific cases in which it can prove that the parallelizing transformation is equivalent. These automatic parallelization transformations are quite limited for the reasons already discussed. For example, compilers can sometimes use SIMD instructions when it detects repeated computations within a loop. Here's an article about how LLVM auto-vectorizes code. Of course, SIMD isn't multithreading specifically, but it is parallelization nonetheless.
   
   
2. u/Pantajones and u/Tai9ch explained about the centrality of dependencies to the problem of automatic parallelization, and your comment about "dependency trees" is an insightful one. If you want to learn more about how these ideas can be applied to building an optimizing compiler, I recommend Optimizing Compilers for Modern Architectures: A Dependence-based Approach by Randy Allen and Ken Kennedy. Be warned: It's an advanced book that focuses on theory, not a book for beginners.

Just in general, or on a specific topic?

Books I'm reading right now:

• Building Microservices: Designing Fine-Grained Systems
  
• The Outer Limits of Reason: What Science, Mathematics, and Logic Cannot Tell Us
  
• Loose Balls: The Short, Wild Life of the American Basketball Association by Terry Pluto (Halfway through, this book is fucking hilarious)
  
• The United States Football League, 1982-1986 (I do not recommend this book... "The $1 League" by Jim Byrne is much better if you can find it)
  
• Football Scouting Methods
  
• Square Foot Gardening

System design is probably the most important thing to learn next. Stuff like SOLID principles, dependency injection etc.
This is a book we use a lot at my company: https://www.amazon.co.uk/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164/

Get a good handle of digital electronics (statemachines, combinatorial logic and registered logic). They'll give you a good basis for building up an understanding of how a computer works.

Digital Design and Computer Architecture
http://www.amazon.com/Digital-Design-Computer-Architecture-Harris/dp/0123704979

That book will take you through basic digital design, Verilog HDL, and then show you how to use Verilog to build a MIPS-like microprocessor (DLX http://en.wikipedia.org/wiki/DLX).

Much of the later material is derived from this book.
http://www.amazon.com/Computer-Organization-Design-Fourth-Architecture/dp/0123744938/ref=pd_sim_b_1

----------------------------------------------------------

Steve Gibson did a series of podcasts called How Computers Work.
http://www.grc.com/securitynow.htm
Search for HOW COMPUTERS WORK

----------------------------------------------------------
If you have any questions or need any other resources in the future, reply to my post.

Two books that will serve you well

1. Building Microservices by Sam Newman
   
2. Production Ready Microservices
   
   It is basically SOA done right as @theplannacleman had mentioned in the comments
   As a primer read Martin Fowlers and Chris Richardsons articles in the sites mentioned below as well as Susans Fowlers post on the layers of microservice architecture here

I find it funny that this guy suggest his audience to read a book that hasn't been published yet.

And then he continues:

> That guy is one of the main guys behind clean architecture.

When the speaker puts in his slides references that he knows nothing about, it says a lot.

You might want to take a look at the book But How Do It Know. It does a great job walking you through how circuits can be used to add all the way up to how those circuits are combined to create a computer. It's geared towards who have little to no experience with programming/electrical engineering.

I highly recommend this:

Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series) https://www.amazon.com/dp/0134494164/ref=cm_sw_r_cp_api_i_weBTCbMNPQ2B1

Also check out Clean Code also by Robert Martin.

Clean Architecture: https://www.amazon.com/dp/0134494164/ (also read Clean Code if you haven't).

Designing Data-Intensive Applications: https://www.amazon.com/dp/1449373321/

Here are few more advanced books that I highly recommend after you learn the basics and want to really implement something.

​

- Modern Compiler Implementation in Java 2nd Edition

- Advanced Compiler Design and Implementation 1st Edition

​

Also here is a link to a GitHub page with tons of compiler related resources. awesome-compilers

Also recommend But How Do It Know? which is a shorter and (IMO) an even easier read than Code.

Once you've read Clean Code, I'd also recommend Clean Architecture which is in the same series. It's at a higher level that talks about how to organize software projects.

>Start at the bottom. Some books I liked...
>
>Learn what a computer does: Computer Organization & design - Patterson & Hennessy
>
>Learn C: Programming in C - Stephen Kochan
>
>VERY IMPORTANT learn your data structures: Introduction to Algorithms
>
>You will have learn Java in university, I found this book good: Absolute Java 4th ed.
>
>This is just scratching the surface, a lot more to learn afterword.

Don't worry, FTFH

Maybe a bit too much to start with but I really like https://www.amazon.co.uk/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

There's a misconception that microservices are 'simple'. That's not always the case, they can be complex, efficent beasts, include caching, handle millions of concurrent requests, etc.

However, architecturally, as seen from the outside, microservices do one thing and do it well.

https://youtu.be/CZ3wIuvmHeM

https://martinfowler.com/articles/microservices.html

https://martinfowler.com/microservices/

First of all you have to ask yourself what your service will do. That will drive the architecture. Your question is like asking 'hey I wanna build an app, how should I architecture it'. It all depends the constraints on your problem.

There are some books on the topic that might help.

https://www.amazon.com/Building-Microservices-Designing-Fine-Grained-Systems/dp/1491950358

I strongly recommend this book and this book

If you go to Amazon's page for the book you can actually find the relevant section on Page 17 of the "Look Inside!" free preview

As far as engineering practices are concerned: Clean Code, Clean Architecture. A secure app/arch is one that is well understood long after you've stopped working on it.

DefCon has a reading list:

https://www.defcon.org/html/links/book-list.html

If you're looking for a starting point, I'd suggest The Tangled Web. Web/browser security tends to be a good high-level starting point.

You asked for books, but I'd highly suggest participating in some CTFs.

Algorithms? Something like hackerrank.com because there you are supposed to create more complex algorithms from the "simple" ones you learn from books or perhaps in college or from Wikipedia/googling/free online resources.

Design patterns? That book specifically and anything from Robert C. Martin, but preferrably Clean Architecture.

If you are poor there are probably PDFs/epubs somewhere in the web but consider buying the books when they made you rich.

I enjoyed writing a small MIPS simulator with this book:

https://www.amazon.com/Computer-Organization-Design-Fourth-Edition/dp/0123744938

I enjoyed building micro services very much.

My other advice would be start building a rest api, figure it out how can you recycle services for multiple sites and what not. As with anything software: Practice makes master.

I found this book to be pretty readable. It uses a simplified MIPS-style processor for everything.

I agree with OP. If you are looking for a good architecture book(s), beside fowlers, I've enjoyed

• Release it (nigard)
  
• sam newman's microservices (o reilly)
  
• Just enough software architecture (g. fairbanks)
  
• but by far, the higher recommandation I can give is
  designing data intensive applications by M. Kleppmann https://dataintensive.net/
  
  I really can't praise Kleppman's book enough.

There's a lot of books written about good programming practices, some of which are more advanced than others. Search around on amazon and you'll find a few.

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164/ref=sr_1_3?ie=UTF8&qid=1520137256&sr=8-3&keywords=clean+code

I cannot vouch for this specific book, but I read another book in the same series, which taught me a lot of things about software design that I had never even thought about.

I think this is a good book.

How Do It Know?

Easy to read introduction to basic principles of computers.

I think you're talking about his new book Clean Architecture.

https://www.amazon.de/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

Look into computer engineering. If you're interested in hardware meets software, you'll explore computer architecture.

See: Computer Architecture Quantitative Approach

and
Computer Organization and Design

And for Clean Architecture fans, coming August:
https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

As for how folks feel about derivative notation? Maybe a little. ;) Sure, Liebnitz had a way better notation than Newton, but folks still use Newton's notation in some small physics examples, so depending on what someone was struggling with... As for SICP, well, it depends, I'd rather someone swallowed a sugar coated pill than spit it out and never get better.

From a compiler design perspective there are really 2 very different paths you can take (they do start to converge at the end, but you still wind up with ANF vs. SSA, etc) You can explore the scheme/haskell/etc functional programming path or you can go down the Steven Muchnik Advanced Compiler Design and Implementation path., which is much more traditional in terms of the kinds of languages it seems to consider.

http://www.amazon.com/Advanced-Compiler-Design-Implementation-Muchnick/dp/1558603204

Both offer very different seeming designs. So, if lisp was a non-starter, I'd probably send them over to the Dragon book and then down towards Muchnik from there.

I'm reading this right now, it's highly recommended.

Building Microservices: Designing Fine-Grained Systems https://www.amazon.com/dp/1491950358/ref=cm_sw_r_cp_apa_i_.TcmDbE37JJPK

Just read the table of contents of a couple of advanced compiler books:

Advanced Compiler Design and Implementation

Optimizing Compilers for Modern Architectures: A Dependence-based Approach

It is a different ball game.

I read Building Microservices by Sam Newman recently. I think it's primarily targetted for people already working in the industry wondering "what the heck is this microservice thing everyone's talking about and how can I go about migrating a monolith-style application to a microservice architecture?"

It approaches the topic in a very pragmatic and practical approach by focusing on avoiding common pitfalls when creating a microservice based application, which I found made it very easy to read and relate to real life situations I encountered in the past.

I don't how suitable it is for a student with little/no work experience, but anyone already familiar with monolithic applications can pick up this book and rake something from it.

Here's the lab course website: https://engineering.purdue.edu/~ece437l/materials.shtml

I'm not sure how helpful that will be since the course was very hands-on and most of the value I got was out of interaction with the TAs.

The lecture notes weren't posted online iirc. The book we used is Patterson and Hennessy

See if your library has this book:

http://www.amazon.com/Computer-Organization-Design-Fourth-Edition/dp/0123744938

It's what we used in my computer organization course and I found it to be quite helpful. If you are desperate, a PDF version of your book is comes up as the second result on google...

I am a fan of JavaScript Application Design: A Build First Approach - a few years old but still very relevant.

First use on-line available resources mentioned already. as far as books go I'm reading "Go in action" at the moment and it has quite interesting approach, more problem based than tutorial.
https://www.amazon.co.uk/Go-Practice-Matt-Butcher/dp/1633430073/ref=sr_1_1?ie=UTF8&qid=1483963854&sr=8-1&keywords=go+in+practice

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

http://www.amazon.com/Structured-Computer-Organization-Andrew-Tanenbaum/dp/0132916525

http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

Check your sources, all of the listed techniques have been around in computer architectures for decades. cfr. Computer Architectures

Computer Organization and Design, Fourth Edition: The Hardware/Software Interface

Another potential replacement for dragon book: http://www.amazon.com/Advanced-Compiler-Design-Implementation-Muchnick/dp/1558603204

This is the third book suggested that was written by Uncle Bob.

Can you maybe explain the Difference between:

Clean Code , Clean Architecture and Clean Coder. All books by Uncle Bob

Why not change the school?

If this is not an option, you have to study yourself. Here are the books:
http://www.amazon.com/dp/0262033844
http://www.amazon.com/dp/0123704901

Maybe this? https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

Per testare le acque velocemente puoi usare https://rubymonk.com/ (introduce Ruby in modo basico). Anche Coursera, Khan, Udacity e simili hanno corsi introduttivi sulla programmazione.

Mentre se vuoi imparare a programmare, il percorso deve toccare almeno tutte queste tappe, in ordine:

1. [Computer Organization and Design](http://www.amazon.com/Computer-
   Organization-Design-Fourth-Edition/dp/0123744938)
   
   
2. The Structure and Interpretation of Computer Programs
   
   
3. Un buon libro di Assembly
   
   
4. The C programming language
   
   
5. Compillers
   
   
6. Code complete, The practice of programming
   
   
7. Fai finta di aver letto tutto The art of computer programming
   
   
8. Un linguaggio a oggetti, magari Programming Ruby
   
   
9. O/E Python, Dive into Python
   
   
10. Design patterns
    
    
11. Impara un linguaggio funzionale.
    
    
    Da qui puoi partire e specializzarti in quello che ti interessa
    
    

Focus on other aspects. Reading and being able to talk architecture has gotten me a lot further than the “cracking the code”, leetCode type of stuff.

(None of these are affiliate links)

https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420

https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature/dp/0134757599

https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X

Computer Organization and Design or Structured Computer Organization

I talk about services and microservices

The DevOps 2.0 toolkit:

https://www.amazon.com/DevOps-2-0-Toolkit-Containerized-Microservices/dp/152391744X

Also available as epub on google books.

I learned mostly from:

http://www.amazon.com/Computer-Architecture-Fifth-Quantitative-Approach/dp/012383872X

But this has alot of information in it, and was the book for the prerequisite of the class I took that Used the above book:


http://www.amazon.com/Computer-Organization-Design-Fourth-Architecture/dp/0123744938

in this book you'll find a chapter on the evolution of PC's architectures and parts, but i'm not sure this is what you're looking for.

Its this one no?

I'm kind of new to programming started at one time and have just started getting back into it, so I lack the jargon and knowledge to be able to communicate with you folks. I bought https://www.amazon.com/But-How-Know-Principles-Computers/dp/0615303765/ref=sr_1_2?s=books&ie=UTF8&qid=1482956438&sr=1-2&keywords=how+do+it+do+it hoping it might help, I'm halfway through it but the fact the book doesn't even mention what a node is was disappointing. I'm guessing the term is specific to the game and not really in the language that author is using.

My complete rebuttal to your poor assessment of the complexity of a computer's architecture is covered here:

http://www.amazon.com/Computer-Architecture-Quantitative-Approach-Kaufmann/dp/1558605967

Anything you do, do not buy this book , or this one . Just a waste of money.

Instead of learning assembly for it own sake I would learn about computer architectonic (eg. Computer Organization and Design by Patterson and Hennessy) after that you will have no problem picking any normal assembly language up in a couple of hours

I myself had it 2 year on my computer science BS.c.