(Part 2) Reddit mentions: The best windows operating system books

Here is how I go about trying to become an "expert":

In short, if you have ever read Alan Perlis's "Epigrams on Programming", most of the things there are pithy explanations of what I'm about to say. Probably my favorite epigram as it relates to being a "language lawyer" is:

​

>10. Get into a rut early: Do the same process the same way. Accumulate idioms. Standardize. The only difference(!) between Shakespeare and you was the size of his idiom list - not the size of his vocabulary.

​

This is critical, because, as most here will tell you, it's nearly impossible to keep every aspect of C# - both how and why - in your head at all times.

​

That said, at one point I was an awful engineer. Let's get into how I became a significantly better engineer.

• ReSharper
  
  • I would diligently fix everything ReSharper would warn me about. Even typos. You might think this is dumb, but as a 12 year old kid, I would sit in IRC chat with the founder of Dinkum Software, Tom Campbell, and he would tell stories about how many places he's consulted for where the engineers would ignore compiler warnings.
    
• Mastering for loop, foreach loop, while loop, do-while loop
  
  • I practiced a lot of problems from books like Deitel&Deitel, but also read books like Code Complete which talked about off-by-one errors, as well as research by Whitehead et al on bug fix patterns. If you read the research, you'll see that most bugs are caused by relatively simple mistakes. What's also interesting is the same developers repeat the same mistakes. Meaning, if a developer has a bug because they used for loop instead of foreach to iterate over an IEnumerable, chances are they have written code elsewhere in your code base with the same mistake. The same goes for not closing database connections and not using using statements to automatically dispose of external resources (like database connections).
    
• Avoiding Anti-Patterns
  
  • Was told in college, by an engineer from Naughty Dog Software, who worked on Crash Bandicoot and other great games, to avoid using singletons, because you can never predict when you might actually need more than one of something. Gosh, looking back, this simple advice was so hard to follow at the time.
    
  • I read books on the subject of Anti-Patterns, such as Eric Allen's Bug Patterns in Java
    
  • I read blog posts about anti-patterns, and would discuss them with friends. It may sound weird, but I did not want to ever be that engineer who was programming with their pants down and didn't realize it.
    
• LINQ
  
  • I spent a lot of time writing SQL and "Thinking in sets".
    
  • But I also benefited a lot from listening to Bart De Smet talk about The Essence of LINQ and the "MinLINQ" talk he gave on Channel 9: https://channel9.msdn.com/Shows/Going+Deep/Bart-De-Smet-MinLINQ-The-Essence-of-LINQ - at the time, I had been reading blog posts about anamorphisms, catamorphisms, and isomorphisms written by Haskell programmers and most of the stuff flew right over my head, but most of what Bart discussed here deeply resonated with me.
    
• Parallel LINQ
  
  • After digesting Bart De Smet's Essence of LINQ talk, I started to parallelize code at work by figuring out what the serializable sequences of business logic were, and splitting IEnumerable's of my entities via things like candidates and companies, and then passing that down to a timesheet processing engine I wrote.
    
• Task Parallel Library
  
  • This is slightly more complicated than Parallel LINQ, especially if you have not done much concurrent programming before.
    
  • One of the first things I did was search for common TPL bugs on Stack Overflow, via searching for "tpl deadlock asp.net" on Google. Boom. Bunch of blog posts came up written by consultants teaching me some things that I probably learned in my computer science program, probably got right on a test at some point, but forgot about.
    
  • One of the most basic things you can do when writing concurrent code is to know if the libraries you are using are thread-safe. Many libraries will say as much, especially those written by Microsoft. For example, Entity Framework DbContext is not thread safe. If you're going to start using concurrent code, probably the hardest thing to get to grips with is how to safely call non-thread-safe code in a thread-safe manner, or how to look for alternatives that are 100% thread-safe.
    
• Micro-benchmarking
  
  • Learn how to benchmark code. Even if it is just using StopWatch and Xunit to start out.
    
  • Try implementing things two different ways that on the surface seem identical, but are syntactically different, and then figure out why one is slower or faster than the other. If you can't figure out why, ask someone, and then try to generalize their answers so you can apply those lessons learned in other areas of performance tuning.
    
  • Eventually, graduate to newer tools like xunit-performance and benchmark.net
    
• Learn every step of the build pipeline
  
  • I grew up with Visual Basic 6, so I was somewhat accustomed to dragging and dropping objects to create user interfaces, and doing "rapid application development" (RAD). While my first employer helped me break this habit, it wasn't until I read Chris Sells' Windows Forms Programming in C# introduction in chapter 1, "WinForms From Scratch", where he built things from the ground-up, that I started to believe it was even possible to pull back the curtain of such vastly complex systems. In this book, he uses the most basic feature, the c# compiler and a text editor, and doesn't even use *.sln files or *.csproj files. Then he dives into configuration settings XML-first and then shows you the Visual Studio GUI for it after the fact.-- I apologize to those of you laughing at me reading this, but you have to realize, growing up, walking to Barnes & Noble as a teenager and sitting on the floor hoping to one day learn enough to do this cool programming stuff professionally, I had glanced through thousands of books, and this "hands on" ground-up approach was nothing short of revolutionary.
    
  • If you're talking to a database, learn a database migration framework. I recommend FluentMigrator, but I've also used Chuck Norris' RoundhousE and Flyway.
    
  • Learn how to configure and use a build server like TeamCity
    
  • Learn how to configure and use a deployment server like Octopus Deploy
    
• Code as Data, Data as Code duality
  
  • I recommend learning Lisp to deeply understand expression trees, but understanding the trade-offs in storing code as data, and then Eval()-uating it on the fly (such as is done effectively when you call Entity Framework ToList()), can give you powerful new concepts to think about how to solve problems that otherwise wouldn't seem possible without piles and piles of code.
    
• Build a Technology Radar.
  
  • Data mine the crap out of NuGet. Look at what is popular and try to learn about half of those technologies. Chances are everyone commenting here is familiar with at least half of those libraries. Create a scorecard for yourself on a scale of 1-10 for each library on how familiar you are with those technologies.
    
    • Also, don't forget to be reasonable. If you're a computer game programmer, you can probably skip SQL specific libraries like Dapper and Entity Framework.
      
  • I have a radar on my GitHub which ranks various third party libraries and I try to take detailed notes (in private) about why one library is better than another. As an engineer, you'll be asked to solve the same problems over and over again. Figure out the best way and keep track of why it's the best, so you can know when to switch
    
• Testing and writing testable code
  
  • The best thing you can do here is to work with someone who is a master at writing tests.
    
  • The next best thing you can do is probably to learn the basics of writing really clean tests, such as Arrange-Act-Assert, Record-Replay, Mock Objects and Mocking Frameworks
    
  • Become familiar with what can be easily mocked, since it will determine how you choose to design a lot of your object models once you become "test-infected" and write tests as you write your code
    
  • Tools like AutoFixture for generating objects as part of your system under test
    
• Dependency Injection frameworks
  
  • Look at IoC Benchmarks by Daniel Palme. I have learned a lot about performance tuning C# applications by reading through the discussions of issues on this mailing list. Some very smart programmers contribute to this project.
    
  • Learn how you can use a DI framework to create singletons at the container-level, rather than using C# keywords like static.
    
• Combining DI frameworks, AutoFixture and your mocking library to write very concise tests.
  
  • Once you start to see the power of combining a few smaller frameworks, you will begin to appreciate why you don't need big "do everything" frameworks
    
• Generic Programming
  
  • Start off with doing basic generic programming, like strongly-typed collections.
    
  • Graduate to abstractions you might not normally think of, such as generic types that exist only as a "phantom type" to pacify another part of your system, such as a dependency injection framework
    
  • Graduate even further to generic expression trees - functions that return generic code-as-data
    
• I could add more, but I'm at the 10,000 character maximum

> Years ago Lotus Notes was very popular as an email client, but it was garbage.

Because DOS ain't done 'till Lotus won't run

> There is nothing stopping you from releasing competing office software.

Other than not having proper documentation on the secret interfaces that will let it interface efficiently with the underlying operating system.

It's very interesting and telling why you refuse to make any comments on why MS-Office has not created any new, interesting technology for well over a decade.

Don't worry, I understand your motives

Oh, really ? Well, when NTFS first came, it held so many promises. However, I remember reading [the book] (http://www.amazon.com/Inside-Windows-NT-File-System/dp/155615660X) and finding many things that were not in the implementation running on my NT3.1/3.5

So, well, when the first version of your file system promises stuff in its accompaning "inside" documentation, that are not delivered, it is hard to believe that it is due to compatibility.

And the impact on every company's security? Well, this is 1994 we are talking about. Very different times...

The ONLY reason I'm making the money I am today is because of Brian Livingston's "Windows 3.1 Secrets". I read that book all 1000 pages cover to cover and then started fixing every computer I could get my hands on. Through a friend of friend I got hired at a tech support job and it's all history from there.

As everyone has said, PowerShell, but also take advantage of your remote management tools. Grab the Remote Server Administration Tools for your version of Windows from MS and do everything you can remotely. Even better, if you're running Windows 8+ (I know, we all miss the start menu) you can use the new 2012 version of Server Manager (also in the RSAT for Windows 8) to manage them remotely including installing and configuring most roles and features using GUIs.

For PowerShell resources, most of that you can find via Google. I learned my basic knowledge from this book. I also follow this blog to learn some random tips and tricks that I wouldn't learn otherwise.

Most of the value will be for companies trying to make software that will compete against Microsoft products.

Remember the sentence "DOS Ain't Done til Lotus Won't Run"? It has always been a Microsoft speciality, make a public API for the OS that's less efficient than the secret API they use in their own products.

That's why books like this have to be published.

I remember seeing TV ads for the N64, is that good enough? My family didn't even get a computer until 1998 (Win98!) let alone a game console. And I decided it would be fun to read through the Windows 98 Bible, a ~1,000-page book that led me to play around with the OS and become the resident computer expert. (I switched to OS X ten years later, though, after a few years of reading about Linux/OS X/OS9)

Something like this > https://www.amazon.com/C-Cookbook-Stephen-Teilhet/dp/0596003390

Yes. It's like baking recipes. But for C# (or whatever lang you like). You bake/code-along

If you simply must learn MFC, the best books remain the two editions of Jeff Prosise's book on the subject.

The first edition is better, in my opinion. It's available for less than a dollar on Amazon US ( https://www.amazon.com/Programming-Windows-MFC-Microsoft-Foundation/dp/1556159021 ).

It's not "up to date" in that it wasn't written recently and doesn't cover the last two decades' worth of additions to the MFC libraries. It is "up to date" in that it explains slowly and carefully the thinking behind MFC, and how to actually write for it yourself (i.e. not just pushing buttons on a wizard). If you learn form this book, you'll know what you're doing and you can then just browse through the current MFC API to see what additions have been made available to you. Also, by learning from Jeff Prosise, you'll actually have a better understand of MFC than the vast majority of people writing code in it, and you'll be horrified at how ugly and wasteful the wizard generated code is compared to what you can bang out yourself. People with many years' of MFC wizard experience will stand in slack-jawed awe as you craft tight MFC code with the power of your own mind.

Think carefully about why you want to learn it, though. The good reason for learning it would be that you've got to maintain a set of code that use it. If you're looking to get started with GUI programming, it's a bad choice.

Yes, there is.

New Windows Interface (Microsoft Corporation)
http://www.amazon.com/dp/1556156790/ref=rdr_ext_sb_pi_sims_1

One caveat: My copy of this book is at work, so I am relying on my memory. I think this is the one that contains a numbered list of terms in English. The following pages contain the terms that MS uses when they translate to other languages. These lists are not in later editions.

So the English list might have 85. Help If you look at the Spanish page: 85 Ayuda. Look at the German page: 85 Hilfe

Is this what you're looking for?

edit: I'm at work: This is the correct book. The International Word Lists is in Appendix E

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

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

Wow, this totally brought me back to my high school days, when for a time I was carrying around the Waite Group's MS-DOS Bible. (My mom thought I was carrying around a real Bible and that MS-DOS was some new translation...)

If you really want to see how windows actually works there is a really good book called "Windows Via C++". It breaks down almost every base system.

http://www.amazon.com/Windows-via-Edition-Developer-Reference/dp/0735663777

Advanced topics. We're flooded with entry level stuff, don't need more of the same. Advanced isn't just digging deeper into things that re-define the language, we have tons of protocol programming and overriding operators.

There was a "pushing the limits" book years ago... make one like that.
https://www.amazon.com/iOS-Programming-Pushing-Limits-Applications/dp/1118818342

Stopped at iOS 7, make a new version that covers modern things.

I mostly buy physical editions, there are a lot on PC, also collectors editions, but as you said, there is most of the time a Steam key in it besides the Disks.

You can collect on PC quite well, but reselling is history.

As example I bought these three in march (all of them came with a Steam key):

Generation Zero CE

Frostpunk

Pathfinder: Kingmaker

There is a whole sub-profession built around requirements engineering/management that may be of use:


https://www.amazon.com/Requirements-Engineering-Projects-Management-Industrial/dp/3319185969/ref=mt_hardcover?_encoding=UTF8&me=

http://dl.acm.org/citation.cfm?id=2227400

Also, UML and SysML have helped me a whole lot to clarify design elements to junior devs throughout my career. If you aren't expert-level in those, you may want to consider bootstrapping up some expertise ;)


Edit - Books more relevant to Software Requirements Management:

https://www.amazon.com/Visual-Software-Requirements-Developer-Practices/dp/0735667721/ref=sr_1_5?s=books&ie=UTF8&qid=1478992958&sr=1-5&keywords=software+requirements+management

https://www.amazon.com/Writing-Effective-Cases-Alistair-Cockburn/dp/0201702258/ref=pd_sim_14_4?_encoding=UTF8&psc=1&refRID=7273H45W7ZCJHCFZVP7M


Edit 2 - TL;DR - Build out your internal Software Requirements Process.

My first thought was "shopped" but I was surprisingly wrong

If you're interested in this, try and get a copy of the MS DOS Encyclopedia: http://www.amazon.com/dp/1556150490/ - it contains a big chunk of the whys and the hows. It's about 5 inches thick.

I've got a copy of this signed by Mr Gates himself when he attended the IBM PC User Group in 1988. Now I feel old.

Haha. I'd agree except he doesn't really realize it. I think part of it is that he doesn't really have a good understanding of how to wade through forums, as well as his tendency to have gone for more thorough information on stuff rather than specific issues. He could read a modern version of this and be useful, or he can help track down drivers that will work with a laptop that isn't meant for a specific OS, but if he wants to know what kind of extension to download or has some kind of non-obvious error then he goes into 'help me' mode.

Yeah, schools ought to teach debugging, along with source control, how to write tests, how to write documentation, ...

Hard to figure how you'd cram that into a four-year degree curriculum, though. It already seems fairly packed.

Debugging Windows Programs was very helpful to me when I started writing larger applications after college. Not only for Windows-specific stuff, but for developing the attitude of a debugger.

It is standard practice to build the reference image in a VM. Installing applications in the base image it not a good idea. Only do this if you HAVE to. It is better to add all your applications as packages and install via task sequence or as selectable application list during deployment. I would suggest you check out this book:

https://www.amazon.com/Deployment-Fundamentals-Vol-Deploying-Windows-ebook/dp/B00B9IB286/ref=sr_1_5?ie=UTF8&qid=1520347968&sr=8-5&keywords=johan+arwidmark

Ukratko, WPF aplikaciju praviš deklarativnim UI-jem u XML-u i kodom iza koji reaguje na ivente, radi pos'o, itd.. Windows Form aplikacija je sasvim drugi frejmvork sa sopstvenim apstrakcijama i programskim modelom, sve se dešava u kodu. Dve različite .NET UI tehnologije sa istim ciljem, otpr. kao Swing i AWT u Java svetu (ko se seća ovog drugog, nemam pojma da li se to još igde koristi).

Ne postoji jako dobar razlog da danas koristiš Windows Forms, osim ako to nisi koristio do sada i znaš mu sve fore i fazone, a rokovi su pretanki da bi osvajao u procesu novu tehnologiju.

Edit: Ovo je po verovatno najbolja WPF knjiga - WPF Unleashed, tj. bar je bila do pre nekoliko godina, a ovo pamtim kao najbolju Windows Forms knjigu - Windows Forms Programming.

Of course certain Microsoft applications did deliberate use APIs that weren't publicly documented to achieve things there were otherwise impossible.

Any and every bad developer was able to use the same publicly undocumented APIs. The furver started after they were publicly undocumented in Windows Undocumented.

Just because a bad developer is working at Microsoft when he wrongly uses an undocumented API doesn't make it Microsoft's fault.