(Part 2) Best systems analysis & design books according to redditors
We found 868 Reddit comments discussing the best systems analysis & design books. We ranked the 150 resulting products by number of redditors who mentioned them. Here are the products ranked 21-40. You can also go back to the previous section.
The blog The Old New Thing (Raymond Chen) used to (and still does I assume) have all sorts of interesting stories of bugs in Windows. There's a book too that I really need to get around to reading.
This story is the first one I thought of, a wild way to work around a "bug".
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 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:
https://landing.google.com/sre/books/
​
SRE book is free, workbook is not.
https://cloud.google.com/solutions/best-practices-for-operating-containers
https://cloud.google.com/solutions/about-capacity-optimization-with-global-lb
Some of this is google cloud specific but the principles are the same with on-prem or a different provider. "State-of-the-art" deployments are usually learned by using best practices since each distributed app's deployment will vary. These books will help with best practices:
https://www.amazon.com/Microservices-Patterns-examples-Chris-Richardson/dp/1617294543/
https://www.amazon.com/Designing-Data-Intensive-Applications-Reliable-Maintainable/dp/1449373321/
https://www.amazon.com/Designing-Distributed-Systems-Patterns-Paradigms/dp/1491983647/
Hackerrank and firecode.io are great ways to prepare for the initial rounds of phone interviews which usually involve talking to the interviewer over the phone while coding simultaneously on an online IDE like collabedit/hackerrank or google docs. But for later rounds which involve writing code on the whiteboard yourself instead of using an IDE, I think a combination of LeetCode, [GeeksForGeeks] (https://www.geeksforgeeks.org/) and a book like [Elements of Programming Interviews in Java] (https://www.amazon.com/Elements-Programming-Interviews-Java-Insiders/dp/1517671272) work best.
And if you want to prepare specifically for a particular company's interview, then CareerCup is helpful because it provides questions (and usually good solutions) specific to each company.
This might be a good step by step way of doing it:
Depending on skill and knowledge level you might want to skip the first two or one of them at least.
C Interfaces and Implementations has some decent advice for designing C programs. This is also a skill which you 'll develop with time (e.g. over your entire career) so don't worry too much about figuring it out immediately; it requires experience. As you work on various projects you'll get a sense for what works and what doesn't so that over time you'll have developed strategies for solving particular types of problems.
OOP concepts are still valid even though C may not have ways to necessarily implement them within the language proper. Object-Oriented Software Construction is a fantastic book for learning OOP concepts. As your C experience grows, you'll begin to see ways of implementing some of those design strategies with C, even though it's not an OO language.
Knowing when to use what type of data structure can also aid in simplifying your code base. The standard book for this is CLRS, but for C specific implementations and advice, see Algorithms in C.
A good place to start might be books like domain driven design distilled. https://www.amazon.com/Domain-Driven-Design-Distilled-Vaughn-Vernon/dp/0134434420
I've also found O Reilly's building microservice to be a decent primer. http://shop.oreilly.com/product/0636920033158.do
For server less, Martin Fowler is always a good place to start: https://www.martinfowler.com/articles/serverless.html
At first, I was like 'why is the name Raymond Chen so familiar?' Then I remembered- the dude literally wrote the book on this kind of stuff.
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;
Once you've got to grips with running a reliable service then you can start layering your Onion reverse proxy / load balancing on top.
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.
Practical Object-Oriented Design by Sandi Metz and Refactoring: Ruby Edition by Jay Fields, Shane Harvie, and Martin Fowler with Kent Beck were both invaluable for me. They’re more Ruby focused than Rails, but these will help with Rails and so much more.
I apply what I learned in these books in Python, PHP, Ruby, and any other object oriented language I happen to be using.
>would that mean, technical, that you have multiple Order classes based on context?
Yes. Generally you have a "source" domain where the order originates and the order in other domains generally build their order off of the original order one form the "source" domain.
>If so, do they have their own DAL or do they get mapped differently?
Similar to microservices, its recommended that each domain has it's own persistence mechanism. If you've got really big contexts, especially if they have multiple Order types, then you're probably doing it wrong. The ultimate idea is that an Order in each domain is allowed to evolve independently from any other domain.
>I haven't found a "from 0 to done" example yet
From my experience that's kinda hard, just because there's a lot that exists outside the code with DDD. You need to have the documentation and knowledge from the subject matter expert to really understand why certain things are structured the way they are and why certain terms might be used over others.
As far as resources go, the obvious answer is to go directly to Eric Evan's book, but I also feel that's a lot to chew and digest if you're just getting into the topic. My recommendation is to actually start with Vaughn Vernon's Domain Driven Design Distilled, as it gives a higher level overview and description of the concepts of DDD rather than diving into the deep end like Eric's book. From there, I'd either go to Eric's book or to Vaughn's other book, Implementing DDD. Once you get a lot of the concepts, I've found that Patterns, Principles, and Practices of DDD is a good book to get a handle on the code, architecture, and infrastructure implications of DDD.
Introduction to Algorithms by CLRS. Used in almost every algorithms class I've heard of, and a great reference book. It's about 1300 pages, so don't try to read straight through it.
C Programming Language by K&R. This is a C programmer's Bible.
Design Patterns by the Gang of Four
This is a little more of a topic book, but The Art of UNIX Programming by Raymond.
These are all either pretty common, or almost essential. You'll probably see these in your curriculum anyway, and you should. These are a good cornerstone.
I picked up "Programming Interactivity" and installed Processing as my preparation for SNOWPOCALYPSE '10!...
...instead of buying a snow shovel.
> SRE book
Is this the one?
Maybe The Old New Thing by longtime Microsoft employee Raymond Chen? Also dig through his blog archives.
Most other books I can think of are either all about programming for Windows (everything by Charles Petzold, for example), or about Microsoft itself (Barbarians Led by Bill Gates for example). Raymond's book itself isn't exactly what you're looking for either, and I haven't personally read it, but I do follow his blog and if the book is anything like that (I assume it is) it'll be a mix of technical details about why or how something was done in Windows and personal stories about working at Microsoft.
Don't know why this wasn't mentioned yet - but this book is great.
"Algorithms in C"
http://www.amazon.com/Algorithms-Parts-1-4-Fundamentals-Structures/dp/0201314525
OK. ModernRonin did a great job. Read his first. Also I'd like to put out the theory that you didn't receive many replies on /r/programming because that is typically a forum for high-level programming, not down-in-the-metal like this.
I've done this plenty of times, and let me tell you from experience, it can be done on the cheap, and pretty easy. Where ModernRonin provided specific answers, I'll try to provide examples of how it might work.
Something like this:
Temp Sensor --> Sensor control board --> PC.
The link between temp sensor and the board is probably I2C (eye-squared-see) or serial port. If it's serial port, you can technically skip the control board directly to the PC. If you're PC doesn't have a serial port (a 9-pin port that looks like a monitor plugin), then you'll have to buy this, which provides a serial port over a USB connection. If you manage that, then you can move on to adding other sensors to the control board. Typically, these extra sensors will all communicate with the control board, which then relays the data all at once to the PC.
Dont' worry about accessing ports, concentrate on the connections (I2C or USB? Serial or Xbee?), then learn how to access what you have.
Start with the control board, I'd recommend something pre-built like an adruino. Then build your own after a month or so. It's so easy you'll never believe it.
"Choosing" ports won't be an issue, each has a purpose, and typically you won't have a lot of flexibility.
Accessing ports is easy. Start with a terminal program. Realterm is the shit. Be friends with it. It'll dump anything coming in over a serial port, which makes debugging really easy.
Most programs will handle accessing the port for you. However, if you want to build your own program (and you will, probably), you'll have to learn how to do this with code. Luckily, libraries will exist to help you, and you won't be inventing anything so much as tweaking pre-existing examples.
Now the hard part is getting the control board set up. This is where people get frustrated and give up. That's why I strongly recommend paying money for this part. The control board will probably be something like an ardruino. I prefer using Microchip's sample program, which gives you access to cheap chips (but you have to know something about laying out a board).
Once you get this down, you can start building your own sensors if you want. Most control boards will have ADC and DAC which will help you with that. However, you probably will NEVER have to build a sensor.
OK. now a list of literature to get you started.
Programming Interactivity
making things talk -- the BEST book for beginners. I loved this book. If I still had my copy I'd mail it to you right now.
Practical Ardruino
And web sites:
Sparkfun -- hobbyist electrical engineering with tutorials
Microchip -- sign up for their free samples when you want to build your own boards
http://www.arduino.cc -- Excellent Beginner Boards
http://beagleboard.org -- Higher level control board, suitable for larger (but still small) embedded projects
Digikey -- catch-all supplier of all things electrical
Oh finally, do send me an msg if you have specific questions.
We assign mentors (usually the more experienced team members, but can vary depending on project and resourcing requirements) to new guys who will help them get to grips with things like our methodologies, coding standards, etc.
If we end up with a team consisting of a lot of guys without TDD experience (rare, but my teams can vary depending on other projects/resources within my company), we'll occasionally run TDD workshops where one of my senior guys or myself will go through a fill worked example of TDD, and then point the new guys in the direction of suitable resources so they can self learn (although we support them as much as required).
In terms of resources, there are a number of books we have on our internal "recommended reading" list:
There's a lot of information on the web, but I find sometimes books are just the best source.
I highly recommend Kubernetes Up & Running which you can read for free with an individual trial account at https://www.safaribooksonline.com/
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
Junior Software Engineer Reading List
Read This First
Fundementals
Understanding Professional Software Environments
Mentality
History
Mid Level Software Engineer Reading List
Read This First
Fundementals
Software Design
Software Engineering Skill Sets
Databases
User Experience
Mentality
History
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.
https://www.amazon.com/Algorithms-Computer-Science-Robert-Sedgewick/dp/0201514257/ref=sr_1_1?ie=UTF8&qid=1524305825&sr=8-1&keywords=%22Algorithms+in+C%22+by+Sedgewick
or
https://www.amazon.com/Algorithms-Parts-1-5-Bundle-Fundamentals/dp/0201756080/ref=sr_1_2?ie=UTF8&qid=1524305825&sr=8-2&keywords=%22Algorithms+in+C%22+by+Sedgewick
?
You can try this book: https://www.amazon.com/Black-Video-Game-Console-Design/dp/0672328208/ref=olp_product_details?_encoding=UTF8&me=
It covers the topic from first principles.
• Basic atomic physics and semiconductor theory primer.
• Introduction to circuit analysis; current, voltage, and resistance.
• Analog design using discrete components.
• Digital electronics and Boolean algebra.
• Physical hardware construction and prototyping techniques.
• Combinational logic and advanced integrated circuit building blocks.
• Finite state machine design.
• Computer architecture and design.
• Understanding and using microprocessors and microcontrollers.
• Developing software for embedded systems.
Damn right.
The main reason I like my algorithms textbook is because of all the helpful pictures on every page. I forgot most of the stuff the book says, but I learned the algorithms and how to reason intuitively about algorithms by looking at the pictures.
I would simply look at getting a book like "Docker up and Running"....if you're going the Docker route I'd also look at something like an orchestration platform (Kubernetes, Mesos, etc). Personally I'd say go with Kubernetes, it's what Google's been using in-house for about a decade or so. Kelsey Hightower just released the "Kubernetes up and Running" book recently. If you don't know Docker at all though, start there first, b/c the foundation for almost all Kubernetes setups is still Docker.
https://www.amazon.com/Docker-Shipping-Reliable-Containers-Production/dp/1491917571/ref=sr_1_1?ie=UTF8&qid=1493307612&sr=8-1&keywords=docker+up+and+running
https://www.amazon.com/Kubernetes-Running-Dive-Future-Infrastructure/dp/1491935677/ref=sr_1_2?ie=UTF8&qid=1493307612&sr=8-2&keywords=docker+up+and+running
Some vids of Kelsey's talks about Kubernetes: https://www.youtube.com/results?search_query=kelsey+hightower
Orchestration is big right now for Dockerized environments and webapp deployment, so getting to the point of being able to design a full CI pipeline around Github/CI (Jenkins, CircleCI, etc)/Kubernetes would give you a huge leg up in a job search right now.
The book focuses on Open Source code mainly written in C. It assumes that the reader has a basic understanding of programming. It's a book for intermediate programmers, not a book that teaches programming. See the customer reviews on Amazon: those e.g. who expected an introductory programing book were disappointed.
An excerpt from a good book on distributed systems.
> However, distributed systems differ from traditional software because components
are dispersed across a network. Not taking this dispersion into account
during design time is what makes so many systems needlessly complex and results
in mistakes that need to be patched later on. Peter Deutsch, then at Sun
Microsystems, formulated these mistakes as the following false assumptions that
everyone makes when developing a distributed application for the first time:
> 1. The network is reliable.
2. The network is secure.
3. The network is homogeneous.
4. The topology does not change.
5. Latency is zero.
6. Bandwidth is infinite.
7. Transport cost is zero.
8. There is one administrator.
Extract properties into a class, so if you have a class like
Userand it has a series of address properties, create anAddressclass and extract those properties out into your new class and make sure itbelongs_to :user. Then, if other types of classes need something similar (such as aBillingobject), you can use the same class and have that belong to that object as well.As far as naming, feel free to use whatever you want, though it might be best to use
provinceinstead ofstatesince the word "state" in programming means something different, not to mention a province generally covers that same kind of location as a US state does (in fact I'm pretty sure under the hood Google Maps API handles it this way as well). Also make sure you store zip codes as a string since many countries use letters in their zips and US zip codes use a dash to include localized neighborhoods or PO boxes.I'd pick up a book like Refactoring (Ruby ed.) which covers this pattern and a whole lot more.
I think it's just a really simple tasking system. I've never done any compiler design, but have done a half dozen OSs for embedded projects. I have a couple 32 bit OS books with full source code.
MURTL is one, RTOS-II (micrum?) is another. Everything at ring 0 and no paging infinitely simplifies things. It's still a considerable amount of work if it talks to he hard drive to boot.
My opinion:
On one hand, you should learn what you can do with the tools
Mocking framework
Testing framework
Various other tools / techniques / patterns (thinking about test data builders, object comparison, code coverage...)
This part is not necessarily difficult. The basic mechanics of moq and xunit can be learned in a couple of days, maybe less
Then, on the other hand, you must learn proper and useful ways to use those tools to have meaningful tests. And this is harder, the job of a lifetime of testing. I would encourage you to:
Check blogs of people like uncle Bob
Peek into how other people in successful projects do testing. Enter github, and look for repos
Books. I can recommend you this one: https://www.amazon.com/xUnit-Test-Patterns-Refactoring-Code/dp/0131495054
I found that a lot of the concepts it employs and hooks and the top-down design view only came into focus and understanding for me once I've read the book kubernetes up and running. The documentation is nowhere near the simplistic explanation of this book which made everything painfully clear.
Once I've read that I was able to come up with this post: Deploying clustered applications with Kubernetes where I'm deploying a multifaceted, distributed application with it.
Granted I still found some troubles along the way, but once I did that, everything made sense. :) I also wrote a bunch of beginner explanations which clarifies the main design of it. Hope this helped a little.
This whole thing is in such stark contrast to what Andrew Huang who holds a Ph.D in electrical engineering from MIT did in 2003 by not only hacking the first Xbox but also writing a book about it!
https://www.amazon.com/exec/obidos/tg/detail/-/0131429019/104-5607387-8275944?v=glance
I looked at the FreeCodeCamp curriculum, it looks good for an entry level javascript developer, so since you already started it, you might as well finish it (since, like I said, everybody implicitly expects you to know at least one of python/js/perl as well as HTML+CSS).
2 hours per day is a bit too little IMO - but I understand that it's hard to find time when you have a demanding job and a family that needs time and attention. Just study as much as you can, 2h being the mininum (do keep in mind that CS students, your competition, will be studying at least 8h/day for at least 4 years with tons of homework and more advanced material). So you should probably focus on studying more in the weekends (just typing and thinking about this, I'm actually lucky I started when I was a kid, with all my bills paid for!)
Anyways. You should focus on getting a job first - do keep doing the FreeCodeCamp, as many hours in the day and weekends as you can. Explain to your significant other, if you haven't already done so, your plan - that you're studying hard to upgrade your career, that it might take some time away from them but it will pay off in the long run, etc. Ideally you should be studying at least 4h/day, so try to keep close to that, study more on weekends if necessary. Check this guy for reference on his plan and what he's studying (and note that he's studying full-time - a luxury, I know, but just to put your 2h/day into perspective). This guide is helpful too. Note that you don't need to know all that to get an entry-level development job, but keep that plan in mind for the long run (as you progress your career).
Once you finish the FreeCodeCamp, or even before (I would say, once you finish "Basic Algorithm Scripting"), try doing some local interviews if you can do it without jeopardizing your current job just to get a feel of how interviews work. You won't be trying to get a job (but hey, if you do, awesome), this is just to get your feet wet on interviewing (which is a skill in itself). Since you're not shooting to get a job right now, you won't be as nervous, which is the state of mind you want to be in. If you're relaxed you can talk better, think better, make jokes, be more presentable, which is great - this will put you in the right mood for your future interviews. Try finding people online that can do mock interviews with you in the area you will be focusing on (web/javascript/frontend initially).
Once you're past the basic HTML/CSS part and you start studying JavaScript, I suggest you look into Python as well at the same time. It is a very simple language, quick to learn, and will double your opportunities for employment. As you study both at the same time, you might notice that you like one or the other better - if that happens, focus more on the one you like better, this will accelerate your learning and get you ready for a job faster in your chosen language.
At one point you'll finish HTML/CSS and JavaScript+Python (finish as in be comfortable with them - you'll see that you'll still learn new things as years go by, it will take a few years for you to "master" them). After you're comfortable with JavaScript and Python (and hopefully gainfully employed in development), start studying that book (where you'll learn a GREAT deal about many important things, it will be a dense read, and you will come out of it knowing assembly and C) and then you can focus on algorithms and exercising your thinking with algorithmic puzzles and how computer networks work, operating systems and everything that is generally on this list.
Then after studying all that and with 2-4 years of experience under your belt (and still studying 4h/day), you can start thinking about the next level in your career and preparing for it (larger companies, mid to senior positions, etc) - add a couple more years of experience and you'll be ready to interview for large Valley companies (Google, Apple, FB, etc).
If you plan to self-study all the way through and never join an University, you can look into full-fledged CS courses online and follow that to get a complete theoretical background on CS (that all your colleagues will eventually have and expect of you, at some point in the future).
Okay so there are a couple of good places to start with malware. The first is Malware Analyst's Cookbook. It is a pretty decent beginner level resource.
From there, Practical Malware Analysis is excellent and goes a lot deeper.
For free resources I've heard good things about Dr. Fu's Malware Analysis Tutorials.
You will need to have a strong understanding of reverse engineering. I like Practical Reverse Engineering or Reverse Engineering for Beginners. The latter is free.
With RE comes assembly. I learned from the free book PC Assembly Language. The RE books should have some info on assembly as well.
You should also know the systems programming API and OS internals for whatever OS you're interested in. This is most likely Windows, so I recommend Windows System Programming and Windows Internals. You can find similar books for Linux and macOS too. Having a good understanding of C and C++ is helpful for this. Also get comfortable using your assembly level debugger on your OS of choice. WinDBG, x64dbg, and OllyDBG are all good on Windows. GDB is pretty much the default on Linux, and LLDB on macOS.
I also highly recommend some scripting language, whether it's Python, Ruby, Powershell or whatever for hacking up your own tools.
Lastly, there is a list on GitHub with a ton of helpful links.
I think that's enough for now.
As far as demand it's hard to say and probably depends a lot on where you're from. It's certainly not like the demand for webdevs but there's also not nearly as many people with the skillset. I'm not a malware analyst myself, I'm more focused on security research and embedded development.
I know those skills are especially high in demand around the Washington, DC area with defense contractors and government agencies. Especially if you can get a security clearance. Most other security firms I know of are always looking for good people with strong reversing and OS internals knowledge.
Let me know if you have any questions and I will try to answer.
You were not really clear about what you are hoping to get from it. At the simplest level a computer is little more than a calculator with memeory. If you are wanting to make a simple microcomputer you could base your design off of two of the earlierst ones, the Mark 8 and the Altair 8800. If you follow the external links you will eventually find your way to manuals and schematics. If you want to actually build your own processor you could do somthing like Magic-1 which is a TTL implemented minicomputer. That site is part of a webring of related sites. And finally, if you would like a relatively friendly high level overview of everything from basic circuits to software I would recomend The Black Art of Video Game Console Design. Hope some of this helps, and best of luck with the project!
I enjoyed this one: http://www.amazon.com/Refactoring-Edition-Addison-Wesley-Professional-Series/dp/0321984137 and http://www.amazon.com/Eloquent-Ruby-Addison-Wesley-Professional-Series/dp/0321584104/ref=pd_bxgy_b_text_z
Your link looks like a pirated copy of the book. Here's the real one:
​
https://www.amazon.com/Introduction-Design-Analysis-Algorithms-3rd/dp/0132316811/
​
Levitin's book is great. I'd also recommend Sedgewick:
https://www.amazon.com/Algorithms-Parts-1-4-Fundamentals-Structure/dp/0201350882
​
There's also a Java version of Sedgewick if that's your thing
You may want to check out this book (it doesn't have to do with the Xbox one though)
https://www.amazon.com/Hacking-Xbox-Introduction-Reverse-Engineering/dp/1593270291
https://www.amazon.com/Developing-32-Bit-Operating-System-Cd-Rom/dp/0672306557
Course: UC Berkeley OS & Systems Programming
The Art of Unix Programming
There are many similar resources out there. Extract keywords, web search, repeat. Best of luck!
In that case...
You may want to wait for the 5th edition of UNIX and Linux System Administration, as it should release near the end of this year and they don't release new versions that often.
A good way to get started building a college library is to see what the curriculum for the school is and what books are required by professors. Often other colleges will list their book recommendations for the courses online to get an idea of where to start looking. (I know my school has an online bookstore that lists the books for each course and is open to the public)
At least one or two good books in each of those categories, to get a rough idea to start:
C, C++, Java, Python and Ruby are popular to start with
https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739
https://www.amazon.com/Programming-Paperback-Addison-Wesley-Microsoft-Technology/dp/0134382250
you already have a couple here
https://www.amazon.com/Artificial-Intelligence-Modern-Approach-3rd/dp/0136042597
https://www.amazon.com/Windows-Internals-Part-architecture-management/dp/0735684189 (coming soon)
Edit: On second thought, pretty much every college teaches system programming on linux - so perhaps just the linux texts would be adequate for that.
Good advices for code reading strategies can be found in this book http://www.amazon.com/Code-Reading-Open-Source-Perspective/dp/0201799405, not in Go however.
Algorithms in C++ by Robert Sedgewick. If you go through this book and actually try out all of the examples, you will be well on your way to being a good programmer. It's not language agnostic, but C++ is a good place to start. Once you've gotten programming concepts down in one language, it's easy to apply them to another.
No, no, no. The principle is great, but that book is bonkers.
You want the Vaughn books if you're doing DDD:
The bigger book: https://www.amazon.co.uk/dp/0321834577/ref=pd_lpo_sbs_dp_ss_1?pf_rd_p=569136327&pf_rd_s=lpo-top-stripe&pf_rd_t=201&pf_rd_i=0321125215&pf_rd_m=A3P5ROKL5A1OLE&pf_rd_r=83Y7X80HPERQ5AMCEXGG
The shorter book: https://www.amazon.co.uk/Domain-Driven-Design-Distilled-Vaughn-Vernon/dp/0134434420/ref=pd_sim_14_2?_encoding=UTF8&psc=1&refRID=M5QXQ063YDX0E768HE3S
Source: read all of them tried getting traction across multiple teams citing them as sources, and the Evans book is almost intractable to most. Vaughn also at least starts talking about CQRS in a reasonable way, and introduces it using DDD.
I think you really need to learn how to program windows in C, not this new .net or sharp stuff.
https://www.amazon.com/Programming-Paperback-Addison-Wesley-Microsoft-Technology/dp/0134382250
https://www.amazon.com/Programming-Windows%C2%AE-Fifth-Developer-Reference/dp/157231995X
edit: oops, you wanted courses, not books.
He used the word "bounded context" using its meaning from Domain-Driven Design approach https://martinfowler.com/bliki/BoundedContext.html and that's what triggered Vernon who is the author of 2 books on this topic https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577 and https://www.amazon.com/Domain-Driven-Design-Distilled-Vaughn-Vernon/dp/0134434420/ . That's what makes this whole conversation funny.
Buy an Arduino or another open source microprocessor and research interactive programming... tinker with embedded hardware. Or switch industries, find a software position within an industry that actually does make a real world impact, preferably one you are passionate about. At my day job I do have some mundane tasks as far as development is concerned but my overall contributions to our final product makes me love my job and remain passionate about software.
>What is the process of extracting the ROM?
Google for "cartridge dumper". People build them. You get bored systems guys reverse-engineering the stuff initially. "Bunnie" Huang is an MIT grad student that built some of the hardware and did some of the hardware-side analysis in breaking the original X-Box DRM system (building demultiplexers and bus monitors, etc) -- he has a book detailing the process and what he did.
"The art of Unix Programming" by Eric S. Raymond. Not as intimidating or outdated as you might think - This book goes over the history and philosophical concepts behind not only Unix (and Linux), but also the Open Source initiative behind Linux. ESR's other work is "The Cathedral & the Bazaar" which is also worth a look, but I would argue is dated now, as much of what was suggested in this book has already come to pass with too many real world examples to mention.
I like this book. it had a section on data structures.
good thing is it comes with C code.
http://www.amazon.com/gp/aw/d/0201756080/ref=mp_s_a_1_5?qid=1452906633&sr=8-5&pi=AC_SX110_SY165_QL70&keywords=data+structures+c&dpPl=1&dpID=51Ea0S0MQwL&ref=plSrch
I always found Stanford list a great place to start with C and Data Structures: http://cslibrary.stanford.edu/
A classic book in C++ and DS would be Algorithams in C++ by Robert Sedgewick
I second the comment to learn SQL really well. Also regular expressions come up frequently enough to be worth learning a bit about. Some familiarity with data structures is worth picking up, and getting a grasp on some common design patterns is well worth the time.
On the last point, I’d recommend Design Patterns in Ruby and Refactoring Ruby
Hope that helps.
Depending on your exposure to exploitation in general, it may be best to briefly introduce yourself to exploitation on Linux first to learn the basics, as there are some additional complexities with Windows exploitation not present in Linux exploitation.
That said, here is a great course that specifically focuses entirely on windows exploit development. Here is an equally amazing series that is probably best used as a supplement during and after that course
If you find that you're struggling with understanding the material (specifically for the OpenSecurityTraining videos), it might be best to follow along the prerequisite knowledge "chain", on the pages for each class (Ex: Confused by exploitation concepts that he doesn't explain in depth in Exploits 2 --> Try out Exploits 1 -- as he probably expects you to know a few things from it already. However, if you find that you may be rusty in assembly --> Sharpen up through their Intro to x86 course, and reviewing/learning C on the side. If you want to understand key differences between Windows and Linux binaries, their Life of Binaries course is pretty good too, but that course itself is not fully necessary for just getting started imo.
If it's a matter of you not being a fan of the teaching style for any reason, an alternative course is Sams Class (which I should let you know ahead of time, covers both linux and windows). Both courses include labs for you to work with as you learn (Sam's class even offering extra mile labs).
As for digging into WinAPI, Windows Internals is probably best used as a reference for when you need it (whether you come across something that specifically requires that information, or reach the point where you need new rabbit holes to dive into). If you can manage to get a course with any of the authors of the book, that may be best for thorough learning of that content. Here is a free alternative, by the co-founder of 'Trail of Bits'.
I personally learned a lot through Windows System Programming and Windows via C-C++, but nothing in this paragraph is necessary to initially jump into windows exploitation. If anything they may be helpful after you start to move beyond the basics.
This book: http://www.amazon.com/Black-Video-Game-Console-Design/dp/0672328208/ref=sr_1_sc_1?ie=UTF8&qid=1394671704&sr=8-1-spell&keywords=blackart+of+video+game+console+design (although a little dated) explains a lot of the basics of EE particularly related to computer design (a video game console is a microcontroller-- more or less-- with capability to read programs from some ROM or the like).
It explains how these things work from both the chemistry and physics view and all the way to digital circuit design. It is quite thorough, though may take some background in at least the relevant math/physics to be useful at the beginning. Other than that, quite easy to follow!
In any event, when it comes to learning computers, persistence is key! Just keep looking at the material and play with the material. Playing is key so you can see how things break and, ultimately, understand why certain things work the way they do. Good luck!
So Assembly -> Forth -> lisp -> ??? -> profit?
If you want to make a whole OS you may want to look at this book. I used to own it. I did not, however write a 32 bit OS. :(
I used excerpts from this textbook in one of my classes and it seemed pretty thorough if not brief: http://www.amazon.com/Distributed-Systems-Concepts-Design-Edition/dp/0132143011/ref=sr_1_5?ie=UTF8&qid=1371163267&sr=8-5&keywords=distributed+computing
Also this one: http://www.amazon.com/Distributed-Systems-Principles-Paradigms-Edition/dp/0132392275/ref=pd_sim_b_1
There's Spinellis also http://www.amazon.com/Code-Reading-Open-Source-Perspective/dp/0201799405
Also there's lots of advice to google on SO, HNetc
but w/o any specifics we can't really help
I will certainly keep the chain going, and I will seek out others as well, btw, http://www.amazon.com/Programming-Interactivity-Designers-Processing-Openframeworks/dp/0596154143 good buy?
I liked this book: https://www.amazon.com/xUnit-Test-Patterns-Refactoring-Code/dp/0131495054
The right level of testing depends on you and on your program. Tests that exercise your entire program with no mocking, doing exactly what it's supposed to do in the environment that it's supposed to do it, are pretty much the gold standard, but there are some things that are harder to test like that, and also such tests tend to be a bit slower to run than smaller tests. Tradeoffs everywhere.
I would very much recommend http://www.amazon.com/Black-Video-Game-Console-Design/dp/0672328208 ; it goes really far in explaining everything from quantum level up to a working game console. And after that; http://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388/ref=sr_1_1?s=books&ie=UTF8&qid=1405346881&sr=1-1&keywords=minix . Then you'll be set.
Edit; Although the Black art is about game consoles; if you work through it, you can build your own computer in the end, or, what I really like, you can pick up old machines (80s/begin 90s) from Ebay for < $5, open them up , understand them and change them. As they are not 'one chip' with some power supply stuff, but almost everything is held in separate ICs, so you can follow the PCB and see actually what it is doing and how. Great fun. And it scales, as I have no issue making digital things with FGPA's etc because I know it at this level.
The book I learned with
It's old, but still the best C language DSA book.
Here's another by Alfred Aho and co.. It's more of a general programming book, but covers most of the introductory DSA topics, and does it well. Brilliant man and a great teacher.
Ah good, household voltage gets complicated. The official arduino site has some great tutorials to get you started, Tom Igoe helped develop the whole thing and has a lot of great stuff on his site. He recommends a few tutorials on that page. He seems to be shuffling his website stuff around recently, so some of it might be hard to find.
I think there have been some good books published recently, like Programming Interactivity that has some good stuff about Arduino in it.
Back to the project though, like some of the other commenters have mentioned, just relating it to pure volume should be simple enough. Audio processing, like eq filtering might be a lot more complicated. I know that there are some bluetooth type connections available with Arduino, although I haven't done that personally, so you might be able to communicate with the board wirelessly.
I know this is an old post, and probably nobody will see this, but: I bought this book and it was exactly was I was looking for:
&#x200B;
Elements of Programming Interviews in Java - https://www.amazon.com/Adnan-Aziz/dp/1517671272/ref=sr_1_1?__mk_es_US=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=2U0T3YHSBVWQB&keywords=elements+of+programming+interviews+in+java&qid=1569364446&sprefix=elements+of+p%2Caps%2C197&sr=8-1
&#x200B;
It has lots of exercises to practice, but best thing is that it has the Big O explanation for each one of the exercises so you can practice that too - And if you get it wrong, then you will know why.
Seems there is a Python and a C++ version. I don't know if they actually have same samples/Big O details.
Ovo su dve "standardne" knjige:
Introduction to Algorithms (Cormen, Leiserson, Rivest, Stein)
Algorithms (Sedgewick)
Lično, ja volim ovu (od drugog autora gore): Algorithms in C++
Dodatno, Knuth je pre neku godinu izašao u PDF-u i verujem da bi mogao da ga nađeš po Internetu, ali iskreno - danas je to nešto gde ćeš se najviše diviti tipografiji, i ako si baš baš baš jako matematički inkliniran dokazima (). Za praktične potrebe 2017. godine bilo šta od ona dva gore navedena je bolje.
() Kome nije dosta matematike u Knuthu - Concrete Mathematics: A Foundation for Computer Science. Opet, možeš provesti udoban radni vek bez da znaš išta od toga, što ne znači da ne treba da čitaš ako nisi radoznao. Svakako ćeš biti u prednosti u odnosu na onog ko nije.
You are studying Computer Engineering. Why not study something more applicable to your field? C++, Rust, Golang? Go through Sedgewick and implement some algorithms and data structures in C? Do the cryptopals challenges in C? Try to implement some of the GNU coreutils for fun. Play with an arduino and\or Raspberry Pi and build a cool robot?
Ah, sorry for incorrectly assuming your intentions. The Java version does have a "look inside" option on Amazon so you can start working through problems while you wait for it to arrive. I think the Python version has "look inside" as well.
It depends on how far and how fast you want to go. If you want to quickly learn enough programming that you can make code that actually does useful stuff then you might want to start from scripting languages like python, bash etc. If you want a solid(but slow) foundation for programming then you're better off starting with C, moving to C++ and then going to high level languages like Java or C#. If you want to start from C, I'd recommend Problem Solving & Program Design in C. You can easily transition to C++ from C. When you've learned enough C++ & want to dive into algorithms, you should read this book by Robert Sedgwick.
If you just want to have fun with Maths. You can start learning Matlab(It wouldn't teach you a lot about general programming though). You can easily start learning image processing & Artificial intelligence with Matlab, and these are really fun things to do.
Unfortunately, there is no single language that you can learn to be able to talk to all phones, computers, fridges and browsers. You have to pick one area and start from there.
There's a book.
If you like low level, and like to code a bit, you might want to look at SRE-style jobs. Some code, some systems engineering. A background in low-level Linux debugging will take you a long way as an SRE.
https://www.amazon.it/Site-Reliability-Engineering-Production-Systems-ebook/dp/B01DCPXKZ6
I recommend the Kubernetes: Up and Running book.
The demos are amazing and it explains everything you might need.
That or DDD Distilled https://www.amazon.com/dp/0134434420/ref=cm_sw_r_cp_apa_DogwzbS6XRA70
It can be hard at first, but it's really worth it. If you surpass the 100 lines limit for a class it's surely doing too much, try splitting it into several smaller classes, or at least some concerns.
Something which can help with that is Refactoring: Ruby Edition, it's more of a senior-level book than POODR, and you can't read it from cover to cover, you have to stop at each pattern, see if you can apply it, then repeat, but it's definitely a great resource, and it helps you "develop an eye" for bad code.
Reek seems to use some smells from the Refactoring book. Not sure if all of them can be analyzed statically though.
EDIT: I didn't know Sandi was updating POODR, I think she's just working on 99 Bottles of OOP, her new book.
I recently got this one.. Data Structure and Algorithmic Thinking with Python
I went through (parts of) the Java version of the book, but also looked at the Python version snippets. The problems that I've seen are identical, and so is the solution style. I'd say go with whatever language you're most comfortable in. There're probably more problems in any edition than you can humanly handle before your interview. This is to say that you don't need to buy whatever is the latest edition of the book.
As zabzonk pointed out , C and C++ are two different languages.
Algorithms in C
Algorithms in C++
Many schools are doing a disservice to the students by treating these languages as one.
C is a procedural language.
C++ is a multi-paradigm language.
Part of the design requirements of C++ was to be compatible with C programs. This was achieved for the most part with a few restrictions. So C++ compilers are capable of compiling most C programs. This is the source of the confusion.
xUnit Test Patterns: Refactoring Test Code
This book might interest you, second hand copys are cheap
http://www.amazon.co.uk/Black-Video-Game-Console-Design/dp/0672328208
His website
http://www.xgamestation.com
Or perhaps start with an amiga or older 8 bit emulator and program in that
For sure! Considering Google invented / defined SRE, and it is being widely adopted over the next 3 years, you will be given a leg up.
I have two books to recommend:
This is the initial book, basically written by Google:
https://www.amazon.com/Site-Reliability-Engineering-Production-Systems-ebook/dp/B01DCPXKZ6/ref=sr_1_1?crid=96VEB008DH8W&amp;keywords=site+reliability+engineering+book&amp;qid=1554953445&amp;s=gateway&amp;sprefix=site+reli%2Caps%2C149&amp;sr=8-1
There is a free version online as well:
https://landing.google.com/sre/books/
Also, I bought this a few months ago that is a follow up, kind of an introspective view of the concepts in the first:
https://www.amazon.com/Seeking-SRE-Conversations-Running-Production-ebook/dp/B07GQ2YY1D
Between SRE and DevOps, there's going to be a TON of money to be made in the next 3-7 years. I highly recommend giving this a strong consideration.
I'd say a fresh developer coming into an org, even as a pure dev, having a background in SRE/DevOps will give you a leg up in most situations. You can be the guy to spot issues in the planning sessions / scrums / architecture review / etc, and be able to call out holes or potential issues.
Devs in a large company by and large don't consider the support or resiliency to the degree someone who practices operations does. There's a million gotchas.
SRE/DevOps insight allows you to understand the underpinning of delivery and support of an application at another level. The whole concept of these roles is to catch problems before they happen (via monitoring, instrumentation, oncall trees/escalation, dependencies, resolution practices, understanding of DR and availability, resiliency, yada yada), and how to quickly correct and future-proof the code against similar or related issues going forward.
SRE isn't about being the first line on-call guy. It's about building reliable systems and holding devs and product owners accountable to how they spend their time. The balance between features and "issues" is the error budget. Exceed downtime constraints and they must cut into feature time to make the app more resilient.
It's a lot more than that, but that's the core fundamental of how Ops can push back on Dev (and Product), to a point you do not need much more than a level 1 & 3 ops team (1 being "something is amiss, is it fiber or a DC outage? No? Call level 2 (devs)", and 3 being "it's not a code problem (or it is and we can fix it quicker with infra until we can code around it), get infra/SRE involved").
The end goal is to make sure the code going into prod has been well thought out to cover scale, use case, integration, dependencies, security (I added that), recovery time, data loss, etc.
I've been on both sides of the fence and straddled it for 15 years. Most issues are solved with code. Putting the dev teams on 2nd line is the best route. Aside from a fiber break, in a resilient cloud environment, the issue can be resolved fastest with code. Put them up front, and they will write more resilient code so they don't get woken up.
This is going to be table stakes in 5 years. If you are starting now, get in now at the forefront of how to tackle these problems. You will be the Golden Child.
I'm not sure if I know exactly what sort of interactive design you're thinking of but I do a lot of work with Arduinos and I can recommend this book.
I did a class on distributed systems which was practically a spoken version of the textbook Distributed Systems: Principles and Paradigms. Some of the book is good, others is meh. If you don't want to read it check out the stuff in the table of contents and read stuff based on that.
This book covers a lot of the material that Beegram2 mentioned. If you want a cheaper version, there's also this. Both contain a number of errors but I think the latter is slightly worse. Still an amazing book, though.
I suggest you read the book Code Reading - Open Source Perspective
Lots of examples of good (and bad) code in the book.
http://www.amazon.co.uk/Code-Reading-Perspective-Effective-Development/dp/0201799405/
https://www.amazon.com/Algorithms-Parts-1-4-Fundamentals-Structures/dp/0201314525
I am not sure if this meets your requirements directly, but it not only discuss the algorithms and the analysis of them, but detailed implementations in C.
There are ones in C++ and Java as well by the same author. Probably worth checking out if you prefer them over C.
Actually, if you want to know an even better one, this series for Data Structures and Algorithms: https://www.amazon.com/gp/aw/d/8192107590/ref=pd_aw_sim_14_of_16?ie=UTF8&amp;psc=1&amp;refRID=C98R4Q72Z8N155CN2C14
The covers are ridiculous, but these are the best.
I've enjoyed the xUnit test patterns book. It's all about fundamentals that span languages and frameworks.
http://www.amazon.com/gp/aw/d/0131495054
this is the bible of distributed systems. I really recommend it, I think your book has a lot of modern stuff, but this one cover all the fundamentals that every distributed system is based of.
https://www.amazon.com/Designing-Distributed-Systems-Patterns-Paradigms/dp/1491983647
Start hacking the linux kernel. See how it's really done. Become disheartened if you are one of the 99.999% of people who don't get it.
Forget this idea for a while (a year at least) then start over again with renewed resolve. Repeat until married or dead.
Somewhere along the line read the following:
Synthesis
Writing Your Own 32-bit Operating System
You can stop this madness by realizing unix does enough for you to get your work done and learning Lisp.