Terry Brown’s Post

At the risk of sounding cocky... Here's the #Ifeora theory on software engineering (as follows): " All of software engineering (e.g. SOLID, Design patterns, DDD, TDD, Static Types, Embedded systems, Distributed systems, Infrastructure) can be distilled into 2 points: - Abiding by a set of meaningful constraints - Deciding off of a set of reasonable trade-offs And trying not to overdo any of the two above " When building/writing software we are constantly making trade-offs on what we are doing, how are doing it, when we do it, where we do it or don't do it. We are regularly making an #Effort vs. #Reward choice and/or #Cost vs. #Benefit choice. For example, people who dislike SOLID principles completely say it leads to poor performance and isn't explicit enough but in the grand scheme of things, SOLID is just a set of choices that bother on #Cost vs. #Benefit. SOLID cannot be thoroughly explicit too because it centers around trade-offs and depends on context. Remember why senior engineers always answer pertinent questions with "It depends..." ? Well, it applies here to. The constraints part is what keeps accidental. complexity, chaos of scale and emotional frustration as we build software under control. Have you noticed that whenever you are building/writing software with zero constraints; things get out of hand real fast ? Static types are a very good example of a meaningful constraint. Yes, it can take some getting used to as it inconveniences you in the beginning but as time goes on you value the benefits over the discomfort (See 😀, we just circled back to the #Cost vs. #Benefit point i was making earlier). When you come across a software library/framework that describes itself as "opinionated", it simply means that the library has created a set of meaningful constraints that you as a user of the library/framework need to abide by. On average, the "opinionated" libraries/frameworks are usually better and more useful than the "unopinionated" ones. I just published a brand new article on software. You can read more here: https://lnkd.in/dDf95Hup You're welcome 😁😆😎

🚀 Become a Coding Master with Software Engineering Best Practices! 🚀 The dream of every developer? A high-performance application that's seamlessly compatible, secure, and scalable. This isn't just a fantasy – it's achievable by following established software engineering best practices. These practices are the collective wisdom of decades, continually evolving to meet the ever-changing demands of the digital landscape. Think back to the pioneering work of Professor Friedrich L. Bauer in the 1960s. His legacy lives on in modern languages like Java, Python, and Ruby. Our latest article dives deep into why these best practices matter and how they can transform your development process. 🌟 Highlights include: • Why Software Development Best Practices Are Crucial • Key Software Development Best Practices to Implement Today Don't miss out on this essential read! 👉 Read the full article here: https://lnkd.in/dkDq7_-U #SoftwareEngineering #BestPractices #HighPerformance #Scalability #Security #IntelliSoft #Developers #TechInnovation #CodingMastery

🔍 Dive into the Core: Exploring SOLID Principles in Software Engineering 🖥️ Welcome to a journey through the foundational principles of software design! In a landscape where adaptability and maintainability are key, SOLID principles stand as guiding lights for developers worldwide. In this blog, we embark on a deep dive into each aspect of SOLID: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. From understanding their essence to exploring real-world applications, let's get equipped with actionable insights and empower our coding journey. Let us unravel the history, significance, and practical implications of SOLID principles, pioneered by none other than Robert C. Martin (Uncle Bob) himself. Discover how these principles transcend time, shaping software engineering practices since the early 2000s, and continue to be indispensable tools for crafting clean, maintainable, and scalable code. Whether you're a seasoned developer seeking to refine your skills or a newcomer eager to grasp fundamental concepts, this blog promises to be your roadmap to software craftsmanship excellence. Let's embark on this exploration together and unlock the full potential of SOLID principles! 💻✨ #SOLIDprinciples #softwaredevelopment #design #engineering

As engineers, we always tend to solve all problems with code. Yet, during many years in the industry, I learned that sometimes the best solution involves no new code. This realization hit home during a project where we could eliminate an entire planned microservice by simply reconfiguring an existing system. Before adding a new feature or function, ask yourself: "Is this really necessary? Can we solve this problem without adding more code?" Don't write if you're not sure you need that line of code. The best code is no code. And this is true because every line of code you write is a liability. It needs to be maintained, tested, and potentially debugged. It also increases the cognitive load for other developers (including your future self) who need to understand the system. Remember, your goal is to solve problems and deliver value, not just to write code. The simplest and most maintainable solution often involves writing less code, not more. Think like a product-minded engineer, not a code monkey. So always think twice, and code once! A wonderful article by Dr Milan Milanović https://lnkd.in/d9ymRYJc

I think many junior - mid level engineers don't realize how important it is to become aware of "Domain Design" as a principle and a skill. a quick definition: "how a companies software models business concepts and processes, aligning system structure with goals for effective contributions". 1/2 of a new hire’s onboarding is the chaos in learning all the terms, acronyms, abbreviations, contrived entity names .... and how it all fits together with the real-world business problem the software addresses. It requires familiarity with key entities (e.g., customers, orders), their relationships, and how they map to system components like databases, APIs, and services. Speaking from experience, this was by far what tripped me up the most in getting up to speed with a company/team. The problem was that I didn't recognize this as a skill like any other. I thought I'd just have a few "knowledge dump" sessions with a tech lead and be good to go. Here's the take-away: It IS a skill, just like writing good code, and you DO need to learn it to be successful on a team. Here's a book I picked up recently on the subject:

If you want to become a better senior software engineer, read these 10 articles: ↓ 1. How to have a better code reviews in your team. https://lnkd.in/eGCMGqDV 2. How to behave as a senior software engineer. https://lnkd.in/ewszA-B6 3. How to succeed in coding interviews https://lnkd.in/eQUVTtyG 4. How to define SMART goals and why they are effective. https://lnkd.in/eMnaBgSy 5. How to make impact and create optionality in your career. https://lnkd.in/eVD3wkNF 6. A review of the book "A Philosophy of Software Design". What I found valuable and what I found questionable. https://lnkd.in/eZqpRTwG 7. An overview of the concept of caching and how it is used in distributed systems. https://lnkd.in/e2VXEAjp 8. Message delivery semantics and Hinted Handoff pattern in distributed systems. https://lnkd.in/eGZB_jwx 9. Virtual machines and containers explained in simple terms. https://lnkd.in/eZiqk-rF 10. Why it is important to know the users' thoughts before launching a product. https://lnkd.in/eZ-ucvRd

Last week, I came across an insightful blog post by Ozan Akman discussing the importance of soft skills in software engineering. The key takeaways from the post include: 1️⃣ Complaining vs. Problem-Solving: Soft skills are crucial for building successful careers and connections. Effective communication is essential for ensuring others understand our perspectives and challenges. 2️⃣ Communication: Staying connected with clients, teams, and managers is vital for understanding and solving problems effectively, without getting lost in technical details. 3️⃣ Ability to Express Ideas: Our ability to express ourselves shapes how others perceive us. Clear expression leads to better understanding. 4️⃣ Constructive Self-criticism: Focusing on actionable changes and practicing empathy are key components of self-improvement. In today's diverse work environments, these skills are indispensable for collaboration and problem-solving. While coding skills are important, true excellence as an engineer is demonstrated through strong communication, adaptability, and problem-solving abilities. The essence of the blog post and the role of an engineer can be summarized as follows: Engineers are not just coders but problem-solvers who communicate effectively. To excel, we must invest in both technical and soft skills. Read the full post here: https://lnkd.in/dSt4-F66

Here (again!) is an article about things you should pay attention to as a developer. And I don't think you can share them often enough. Especially important: Think twice before writing code https://lnkd.in/e-b_dG4x

Software engineers spend a lot of time on code reviews. In most cases, the code review process is slow and error-prone. Many manual steps could be automated. But I found a solution that saved me time and effort. CodeRabbit is an AI-powered tool that makes code reviews efficient and effective. It fits the pull request workflow and provides a better experience to authors and reviewers. These are the features I found more helpful: 1. High-level PR summary CodeRabbit can provide a high-level overview and summary of the code changes. In addition, it gives a walkthrough of the PR, breaking down the changes file by file. This helps the reviewer to understand the changes and their impact quickly. 2. Context-aware assistant CodeRabbit has all the context about your code, whatever the programming language is.   It reviews all the commits, providing incremental feedback to the author. The comments are posted on the lines of the changed code for each file, as a human reviewer would. 3. Collaborative and interactive code reviews You can chat with CodeRabbit and ask questions about the code and the suggested changes. You can also ask whatever questions about your repository, like if you had a personal expert on your codebase. And the cool thing is that the tool learns from your conversations. The more you use it, the smarter it gets, and the better it will be in future reviews. 4. Issue tracking in real-time If you worked on a big project, you know how painful managing the list of issues is. CodeRabbit can do that for you automatically. It identifies issues affected by a code change and flags any duplicate issues. CodeRabbit is not about replacing human code review but augmenting it with AI. If you want to boost your code review process, try CodeRabbit. It will make your job simpler. It is free for open-source projects and has a 7-day free trial for private repos.

How do you write clean code in the era of software engineering? Writing clean code is essential for software engineering's maintainability, readability, and collaboration. Here are some key principles and practices to help you write clean code: 1. Meaningful Names Use Descriptive Names: Choose variable, function, and class names that convey their purpose. Avoid Abbreviations: Use full words for clarity (e.g., use calculate Total instead of calcTot). 2. Single Responsibility Principle One Responsibility: Each function or class should have one responsibility or reason to change. This makes your code easier to understand and test. 3. Keep It Simple (KISS) Simplicity Over Complexity: Aim for simplicity in design and implementation. Avoid unnecessary complexity that can confuse readers. 4. DRY (Don't Repeat Yourself) Avoid Code Duplication: If you find yourself repeating code, consider creating functions or classes to encapsulate that behavior. 5. Comment Wisely Explain Why, Not What: Comments should clarify the purpose and reasoning behind complex code, not restate what the code is doing. Strive for self-explanatory code. 6. Consistent Formatting Use a Style Guide: Follow a consistent coding style (indentation, spacing, naming conventions) to enhance readability. Automate Formatting: Consider using tools like Prettier or ESLint to maintain consistent code style. 7. Limit Function Size Small, Focused Functions: Keep functions short (ideally fewer than 20 lines) to make them easier to read and test. 8. Write Unit Tests Test-Driven Development (TDD): Write tests to validate the behavior of your code, which helps prevent bugs and allows for safer refactoring. 9. Refactor Regularly Continuous Improvement: Regularly revisit and improve your code to enhance clarity and reduce technical debt. 10. Error Handling Handle Errors Gracefully: Use exceptions and error handling to manage unexpected situations without crashing the program. 11. Use Version Control Track Changes: Use Git or another version control system to track changes and collaborate with others efficiently. 12. Code Reviews Peer Review: Regularly conduct code reviews to get feedback and share knowledge among team members. 13. Documentation Keep Documentation Updated: Maintain clear documentation for APIs, libraries, and complex algorithms to assist current and future developers. 14. Avoid Premature Optimization Focus on Clarity First: Write clear, straightforward code before optimizing for performance unless a performance issue is evident. By adhering to these principles, you can improve the quality of your code and make it easier for yourself and others to maintain and extend in the future. #cleancode #softwareengineering #softwaredevelpment #fusionpulsetech