Engineer Mindset
How to think and work like a software engineer?
get out of your comfort zone
experiment, and learn new things every day
embrace failure
an experienced engineer has failed more times than a beginner has tried.
Change your perspective
from: I have to learn new things
to: I get to learn new things
Breaking Down a Problem Into Smaller Parts
Breaking down a problem into smaller, manageable parts is a critical problem-solving technique used across many disciplines. This approach allows for a deeper understanding of each component, making the problem less overwhelming. By addressing each part individually, you can create a clear path toward a solution. This method is especially useful in software development, engineering, and complex project management, where tackling smaller tasks often leads to more efficient and effective solutions.
Stepping Back / Step away
Stepping back or stepping away from a problem can be an effective strategy for gaining clarity. Giving yourself time to think allows your brain to process the information subconsciously, often leading to new insights or solutions. This practice can reduce mental fatigue and help you return to the problem with a fresh perspective, making it easier to approach challenges creatively and more effectively.
The Importance of Learning One New Thing at a Time
Learning one new thing at a time, while connecting it to what you already know, is a key strategy to avoid being overwhelmed. This approach allows you to build on your existing knowledge, deepening your understanding without overloading your mind with too many new concepts at once. By focusing on incremental learning, you ensure better retention and application of new skills, leading to more sustainable progress over time.
Impostor Syndrome
To overcome impostor syndrome, remind yourself that everyone knows things others don't. You have unique skills and knowledge that others may not possess. Also, while you are aware of what you don’t know, others often aren’t, and that doesn’t diminish your competence. Focus on continuous learning and recognize that feeling uncertain at times is a normal part of growth.
embracing what you don't know
this is a chance to learn these things
The T-Shaped Engineer
A T-shaped engineer has deep expertise in one area (the vertical part of the "T") and broad skills across multiple areas (the horizontal part). This allows them to specialize while also collaborating effectively with others. Their combination of depth and breadth makes them adaptable, versatile, and valuable in multidisciplinary teams.
Ikigai
a reason for being
be curious, not judegemental
Walt Whitman
from Ted Lasso
Walt Whitman
Local Environment
the best skill any engineer can have is the ability to learn new skills
Using WSL for Windows
Windows Subsystem for Linux (WSL) allows you to run a Linux environment directly on Windows without the need for a virtual machine. It's lightweight and integrates seamlessly with Windows, making it a great option for developers who need Linux tools while still working in a Windows environment. WSL 2 brings improved performance with full Linux kernel support.
Using Vagrant with VirtualBox
Vagrant, together with VirtualBox, enables the creation and management of lightweight, reproducible virtual environments. It's a powerful tool for developers who need to standardize development environments across teams. Vagrant's configuration files make it easy to automate the setup of multiple virtual machines with consistent settings.
Native Linux / macOS Development
Developing directly on Linux or macOS provides a native Unix-based environment, which is ideal for most software development workflows. With native tools and no need for virtual machines, it offers great performance and is typically favored for server-side development, containerization, and tools like Docker and Kubernetes.
Knowing Your Environment
Understanding the operating system and how computers work is foundational for effective software development. Knowing how processes are managed, how memory is allocated, and how filesystems operate allows you to troubleshoot issues and optimize performance. Whether you’re working on Linux, macOS, or Windows, familiarity with basic system commands, process management tools, and how the OS interacts with hardware can significantly improve your ability to write efficient and reliable code.
Isolated Package Manager
Using an isolated package manager, such as `pipenv` for Python, `npm` with `nvm` for Node.js, or `rbenv` for Ruby, ensures that each project has its own dependencies and versions, preventing conflicts. This isolation allows different projects to run independently without affecting each other’s environment, leading to greater stability and easier debugging. Additionally, it makes it easier to replicate and share environments with other developers, especially in team settings or CI/CD pipelines.
Digging Deeper
logging - structured logging to a file
chrome plugin - debugging in the browser
vscode - step thru debugging
wireshark - network packet capture
mitmproxy - man-in-the-middle the traffic
where else might you get information from?
or where might you take this data?google | chatgpt | stack overflow
asking questions the right way.
(with the data you got)
be aware of what information you are disclosing
you can ask others
but be sure you save those asks, and bring information
1. Embrace Systems Thinking
Think beyond individual components. Understand how different parts of the software interact, affect each other, and work as a whole. Focus on the big picture as well as the details.
2. Focus on Problem Solving, Not Just Tools
Being a good engineer isn't about knowing every tool. It’s about breaking down problems into manageable parts, finding the root cause, and solving them systematically.
3. Prioritize Communication and Collaboration
Successful software development relies heavily on communication. Whether it's documenting code, participating in code reviews, or working with cross-functional teams, communication is key.
4. Learn to Reason About Trade-Offs
Every engineering decision has trade-offs. Balancing between speed, scalability, complexity, and technical debt is essential. There is rarely a perfect solution, so optimize for the best choice under the circumstances.
5. Develop a Growth Mindset
Always be willing to learn. New technologies, frameworks, and practices constantly emerge. Cultivate curiosity and the desire to improve continuously in both technical and soft skills.
6. Understand the Value of Clean Code
Clean, readable code is more valuable than clever, obscure code. It’s easier to maintain, scale, and debug. Write with future maintainers in mind, including your future self.
7. Approach Bugs Methodically
Debugging is an inevitable part of the engineering process. Stay calm, break down the problem, and approach bugs systematically. Understand the root cause instead of applying quick fixes.
8. Use Version Control Effectively
Git and other version control systems are essential tools for collaboration. Learn how to create meaningful commits, branch properly, and handle conflicts gracefully. This ensures smoother team development.
9. Testing is Non-Negotiable
Test early, test often. Well-written tests improve code quality, reliability, and confidence during deployments. Understand different testing levels: unit, integration, and end-to-end.10. Adopt the "You Aren't Gonna Need It" (YAGNI) Principle
Don’t over-engineer by creating features or abstractions that might never be used. Focus on the immediate problem at hand and avoid unnecessary complexity.
11. Automation is Your Friend
Manual processes are prone to error and take valuable time. Automate tasks like testing, deployment, and monitoring to ensure consistency and save time for critical work.
12. Understand the Concept of Technical Debt
All code has a cost. Understand that shortcuts taken today can create technical debt, which will need to be paid later. Regularly review and refactor code to avoid accumulating too much debt.
13. Be Data-Driven in Decision Making
Use metrics and data to inform decisions. Whether you're optimizing performance, identifying bottlenecks, or improving the user experience, objective data helps remove guesswork.
14. Respect the Power of Abstraction
Abstractions simplify complexity but come with trade-offs. They can be powerful tools for simplifying design but avoid layering too many abstractions as they can obscure the underlying logic.15. Optimize for Readability Over Optimization
Premature optimization is a common trap. Focus on writing readable, maintainable code first. Only optimize performance when there is a demonstrated need, backed by data.16. Embrace Feedback Loops
Feedback loops help you iterate and improve your work. Whether from code reviews, users, or monitoring systems, timely feedback will help you adjust and evolve your engineering solutions.
17. Use Design Patterns Wisely
Understand common design patterns but don’t force them into every situation. They are tools in your toolkit but should be used when the problem fits the pattern.
18. Keep Security at the Forefront
Security isn't an afterthought. Think about potential vulnerabilities early on and build secure systems by design. Regularly review code for potential weaknesses.
19. Think in Terms of Scalability and Resilience
Build systems that can handle growth and recover gracefully from failures. This requires thinking about architecture, data flow, and fault tolerance from the start.
20. Know When to Ask for Help
Engineering is a team sport. There’s no shame in asking for help when you’re stuck. Leverage the knowledge of your peers, mentors, and community to solve problems more efficiently.
SOLID Software Principles Overview
The SOLID principles are a set of five design guidelines that help software engineers create maintainable, flexible, and scalable code. Each principle focuses on a different aspect of software architecture, promoting clean and robust designs.
Single Responsibility Principle (SRP)
A class should have only one reason to change, meaning it should have only one job or responsibility. This principle emphasizes that each class should focus on a single part of the functionality provided by the software and should encapsulate it entirely.
Open/Closed Principle (OCP)
Software entities such as classes, modules, and functions should be open for extension but closed for modification. This means you should be able to add new functionality without altering existing code, which helps prevent bugs and maintains stability.
Liskov Substitution Principle (LSP)
Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program. This principle ensures that derived classes extend base classes without changing their behavior, supporting the use of inheritance.
Interface Segregation Principle (ISP)
Clients should not be forced to depend on interfaces they do not use. This principle suggests splitting larger interfaces into smaller, more specific ones so that clients only need to be aware of the methods that are relevant to them, avoiding unnecessary dependencies.
Dependency Inversion Principle (DIP)
High-level modules should not depend on low-level modules. Both should depend on abstractions, and abstractions should not depend on details. This principle encourages the use of interfaces or abstract classes to reduce the dependency on concrete implementations.
some books
read or listen to new things..
audible & speechify are cheat codes I use
Modern Software Engineering by Dave Farley
Summary: "Modern Software Engineering" advocates for a disciplined approach to software development, rooted in empirical data and proven methodologies. Farley highlights the importance of feedback loops, reducing complexity, and making incremental improvements. The book covers key concepts like DevOps, Continuous Integration (CI), and test automation, giving engineers practical tools to adopt modern engineering best practices.
Designing Data-Intensive Applications by Martin Kleppmann
Summary: "Designing Data-Intensive Applications" explores the core components of modern software architecture: storage, indexing, and data models. Kleppmann explains how to choose between various database technologies, the trade-offs involved in replication and sharding, and how to build reliable distributed systems. The book provides real-world examples of data processing and architectural design patterns that can handle immense amounts of data.
The Pragmatic Programmer by Andrew Hunt and David Thomas
Summary: "The Pragmatic Programmer" covers a wide range of topics that are foundational to becoming a better software engineer, including effective coding habits, debugging strategies, and how to work efficiently in a team. The book is filled with practical tips on writing flexible, maintainable code, managing complexity, and learning from failures. It also emphasizes the importance of automation and constantly improving your skills.
The Software Architect Elevator by Gregor Hohpe
Summary: "The Software Architect Elevator" uses engaging metaphors and stories to explore the role of a software architect in a modern enterprise. Hohpe discusses critical topics like cloud adoption, microservices, and how to communicate effectively with both business leaders and technical teams. The book is filled with real-world advice on how to balance strategic objectives with technical execution in complex environments.
Clean Code by Robert C. Martin
Summary: In "Clean Code," Robert C. Martin outlines principles and best practices for writing code that is easy to read, understand, and maintain. The book provides concrete examples of both good and bad code, illustrating how even small changes can dramatically improve code quality. It covers critical areas like naming conventions, function design, error handling, and unit testing, helping engineers develop cleaner, more effective codebases.
some blogs
other engineers are sharing their excellent work
Macquarie Engineering Blog
The Macquarie Engineering Blog offers insights from engineers working at Macquarie, a global financial group. It focuses on the challenges and solutions related to technology in financial services, covering topics like cloud architecture, DevOps, security, and digital transformation. It's a great resource for understanding the intersection of finance and cutting-edge technology.
Uber Engineering Blog
The Uber Engineering Blog dives deep into the technical innovations behind Uber's platforms. The blog covers large-scale distributed systems, data infrastructure, and optimization techniques, with contributions from engineers across the company. It’s a valuable resource for software engineers interested in the complexities of global systems and real-time data processing.
Netflix Tech Blog
The Netflix Tech Blog provides a behind-the-scenes look at the engineering that powers Netflix’s global streaming platform. It covers a wide range of topics, from microservices and cloud infrastructure to machine learning and content delivery optimization. Engineers at Netflix share their experiences on building reliable, scalable, and innovative systems.
Spotify Engineering Blog
Spotify’s Engineering Blog showcases the technology that supports its massive music streaming service. The blog covers topics such as backend infrastructure, data pipelines, and the use of machine learning in music recommendations. Spotify’s engineering team regularly posts about how they scale their systems to handle global demand.
Stripe Engineering Blog
The Stripe Engineering Blog focuses on the technology behind building secure, reliable, and scalable financial systems. Engineers at Stripe share in-depth technical discussions on topics like APIs, cloud infrastructure, and payment systems, making it an excellent resource for developers working on high-availability and security-critical applications.
some podcasts
another way to keep current and listen while you do other things...
Software Engineering Daily
Software Engineering Daily is a daily podcast that covers a wide range of topics relevant to software engineers, from cloud computing and distributed systems to machine learning and security. The podcast features interviews with industry experts, providing deep insights into modern engineering challenges and solutions.
The Changelog
The Changelog is a weekly podcast that focuses on open-source software, the people behind the projects, and the innovations driving the tech industry. Each episode features conversations with developers and maintainers, providing an inside look into the world of open-source development and software engineering trends.
Engineering Culture by InfoQ
Engineering Culture by InfoQ explores the latest practices and technologies that are shaping software development. The podcast covers topics like DevOps, agile methodologies, and team culture, making it essential for engineers and leaders interested in improving collaboration and delivery practices within their teams.
Command Line Heroes
Command Line Heroes is a podcast that tells the stories of the developers, engineers, and innovators who have shaped the technology world. Each season dives into different themes such as the history of programming languages, software architecture, and the evolution of computing, offering a mix of technical content and storytelling.
The Stack Overflow Podcast
The Stack Overflow Podcast covers all things related to software engineering, developer culture, and the latest trends in tech. It features discussions on coding, debugging, and developer life, as well as interviews with industry leaders, making it a must-listen for developers of all levels.
youtube
finding the gems of knowledge among all the content
DevOps Toolkit Series
The DevOps Toolkit Series, hosted by Viktor Farcic, focuses on advanced DevOps topics, Kubernetes, GitOps, and infrastructure as code. It features hands-on tutorials and deep dives into modern DevOps tools and methodologies, making it a must-watch for engineers looking to improve their DevOps skills.
DevOps Toolkit SeriesThe Primeagen
The Primeagen offers a blend of coding tips, development tools, and live streams focusing on topics like Vim, TypeScript, Rust, and high-performance coding techniques. With a quirky and energetic approach, this channel appeals to developers looking for practical tips and an engaging coding experience.
The PrimeagenTech With Nana
Tech With Nana provides clear, beginner-friendly explanations on cloud-native technologies like Kubernetes, Docker, and AWS. Nana’s channel is known for breaking down complex topics with practical demos, making it accessible to both new and experienced DevOps engineers.
Tech With NanaContinuous Delivery
The Continuous Delivery YouTube channel, led by Dave Farley, focuses on modern software engineering practices, particularly continuous delivery, DevOps, and Agile methodologies. It offers in-depth discussions on the principles of building high-quality software at speed.
Continuous DeliveryFreeCodeCamp
FreeCodeCamp is a non-profit platform that offers free coding lessons in a variety of languages and technologies. Their YouTube channel hosts full-length courses, tutorials, and coding challenges, covering web development, data science, machine learning, and more, making it a fantastic resource for learners at all levels.
FreeCodeCampwhat next?
start/continue the practice of learning every day
connect with others
establish a network, connect with me on linked in, attend a meetup and learn something
Ask questions
now its time for the Q/A