I’ve read it many times – that software engineering continues to be the “odd” engineering discipline, where not many lessons are learned, then passed on – and where engineers end up re-inventing the wheel many times over. Compared to structural engineers or mechanical engineers – software development is very “loose”.
I realized that it’s because software development is something that one can stumble into – and “discipline” is purely a personal preference, not a requirement (legal or otherwise)! So if one isn’t aware or doesn’t have the interest to develop professionally, sometimes software can be built poorly – when it could be avoided!
So – if there are people that are simply unaware, this post will hope to serve up everything that you need – at least from my humble opinion and experience – to be a well-equipped software developer and architect.
- Framework Design Guidelines (2nd edition) (~$39)– written by Abrams and Cwalina, the founders of the .NET framework. They learned a lot about what worked and didn’t work over several years and millions of lines of code with the writing the actual .NET Framework. Their guidelines are absolutely the industry standard for .NET coding techniques (well, .NET API design at least). This covers naming conventions, calling conventions, how to design components, etc.
- MCTS 70-536 self-study kit (2nd edition) (~$38) – this book is one of the core books if you are pursuing MCTS or MCPD. This covers just a TON of stuff – pretty much the “guts” of .NET. This book covers:
- Value types vs reference types
- I/O: streams, readers, writers, System.IO namespace, read/writing files, IsolatedStorage, etc
- Regular expressions
- Everything about encoding (UTF-8, ASCII, etc)
- All the collections: List<T>, Queue, HashTable, Stack, LinkedList, etc
- Serialization (XML, SOAP and Binary)
- Graphics – how to draw shapes, text and graphics on a Windows form; also how to manipulate images in memory
- Threading via ThreadStart, ParameterizedThreadStart, ThreadPool, etc
- Everything about AppDomains
- How to create Windows Services
- System.Configuration and everything about configuration
- Instrumentation, performance monitor, WMI and the System.Diagnostics namespace (TraceSource, Trace, etc)
- Code Access Security
- Authentication and authorization with Identies and Principals
- Working with ACL’s in the operating system
- Working with the encryption APi’s in the framework (symmetric and one-way algorithms)
- COM interop and working with unmanaged code
- Reflection and writing dynamic code at run-time
- Sending e-mail
- Globalization and dealing with culture information
- Code Complete (~$39) – this is an industry-standard pillar of software design. This book roughly covers:
- The approach for how to build high-quality routines
- Data structures and typing
- Approaches for using loops and conditional statements
- Self-documenting code
- Approaches to unit testing
- How to approach and make software quality part of your style
- The philosophy behind being a software developer – including curiosity, humility, using existing conventions, etc
- Design of Everyday Things (~$12) –
- (optional) Design Patterns and Architecting Applications for the Enterprise – everyone should at least be familiar with Design Patterns. The Design Patterns book above is referred to as the “gang of four” book based on the four guys who wrote it, and is considered the official source. It is a little bit dry and high level. The other book (Dino Esposito) is much more practical and explains how these patterns can be used.
For software developers, but especially for people who are interested in calling themselves “architects” – this book is quite significant as well:
MCPD 70-549 self-study kit (~$38) – this covers, in one place, the major aspects of software architecture including:
- What are requirements
- How to build use-cases, proof-of-concepts and mockups
- Creating logical models and defining application layers
- Evaluating designs (what to look for)
- Component design
- Component development
- Implementation logic (how to apply: state mgmt, security, services, etc)
- Considering instrumentation
- Approaches to implementing unit testing
- Stabilizing the application
- Evaluating performance
To me, this is the minimum “kit” that absolutely every .NET developer needs. You should own these books; they should be on your desk. Oh – and they should be read at some point too! I get asked sometimes “do you know a good book, where I can learn about .NET?” – and this is pretty much my answer, this is “the baseline”.
In addition to all of this, I think anyone would benefit from using FxCop with EVERY application. FxCop is a static code analysis tool that will scan your assembly and look for issues with: security, performance, maintainability or naming standards. FxCop has made me a far better developer. When you first use it, you will get like 1,000 error messages – but if you give it a chance and actually read what they are and WHY those issues were flagged, you may learn some things along the way!
I just think that if “this” was the standard – and all developers were familiar with this same baseline of information, I think better software might get built!
And to be clear – I’m not trying to be preachy with any of this. I too, struggle with trying to make the process of making software, easier, faster and better all the time. I’m only now coming up with my list as to what I’ve benefited from – and I think others would too. So, I hope this helps!