Nexton’s Post

Embarking on the software engineering journey brings both delight and challenges. In my latest (and first 😆) article, I dive into important truths, not all truths, that may help new comers, from my observations, succeed in this field: 🚀 It's about engineering, not just programming. Escape the hypes! 🤝 It's about being a team player, not a hero. It's a collective sport! 🗣️ It's about communicating as much as coding 🌟 It's about impact and quality Over quantity ⏰ It's about good habits rather than genius improvisation 🌿 It's about taking care of yourself. It's crucial for your safety! ❓ It's Okay Not to "Know it All". You won't "know it all" but you need to strive for! These insights are allies in your software engineering journey 🚢 Feel free to comment if you see some misses 😉

Software Engineering ignites Problem solving in a Structured Manner. 🚀☀️ Whenever I get a complex technical problem to solve, we have a structured way to approach it. ⚡️ 🚀 Step 1 - Ideation / Brainstorming Phase: Technical team sits together and brainstorms on the complex problem to solve. Here we debate around multiple potential solutions and choose the most optimal one. 🔥 🚀 Step 2 - Documentation Phase: Once we have a high level solution in mind, it’s time to document it. Here we create a Technical Design doc clearly stating out the solution we are going with and the reasons behind it. We also mention other potential approaches discussed and why they didn’t made the cut. ✍️ 🚀 Step 3 - Implementation Phase: We implement the complex solution which we documented in the previous step. Here comes the actual coding part. Our implementation / code is thoroughly reviewed by our peers to avoid issues and enhance the readability. 🧑💻 🚀 Step 4 - Monitoring and Alerting Phase: Once the solution has been implemented and it’s on production, it’s time to monitor its performance and throw any alert incase of an exception. 🚨 A complex problem at start can always be solved with a structured approach in hand. Thats what Software Engineering teaches us 🥂 #softwareengineering #programming #coding

When we write unit tests after writing production code, we are doing the work twice. Write production code, attempt to write test, change production code to make testable, write test. My son learned a little hack while doing his homework. Conventional wisdom tells us this form of batching is faster. It allows us to report a new status of doneness. We crave this false sense of completion. This is human nature, exemplified through the eyes of a child. According to The Marshmellow Experiment, these traits don't change much as we become adults. That's debatable, but hear me out. He eventually learned that he was doing each problem twice and it was taking him longer to complete the assignment. We move faster with frequent and early feedback. Test driven development is one technique that allows us to achieve this efficiency.

Code reviews are a staple of collaboration in software development. So this week for Research-Driven Engineering Leadership, we looked at the frequency of destructive code reviews, and how that impacts software development. Some findings include: ✨ 22% of respondents reported receiving inconsiderate feedback at least once a year, and 55% of respondents reported receiving nonspecific negative feedback at least once a year. Few people reported actually giving negative or inconsiderate feedback... ✨ Compared to constructive criticism, destructive criticism negatively impacted motivation to continue working and the mood of participants ✨ Compared to men, women were less motivated to continue working with the developer who gave the feedback. Read more here:

4 Tips To Improve Code Review Process In A Software Engineering Team Code reviews are a common practice to improve code quality and limit human error. CR is also an excellent learning opportunity for the coder and reviewer. However, they can quickly become a bottleneck in the development process. For this reason, here are 4 tips you can follow to improve your code review process: Tip #1: The reviewer must assume the code works. When doing a code review, you should trust your teammates. Assume they tested their code locally. So, please don't pull the branch; test it locally. Assume they already did that. Tip #2: One approval is enough. Some companies enforce multiple reviewers per PR. The "2014 State of DevOps Report" discovered that any review held by people outside of the team has 2 consequences: 1. decrease performance 2. no quality improvement Tip #3: Consider Sync Code Review Many people associate CR with comments in PRs. However, code reviews can also be conversations with a peer in which you discuss changes. Instead of waiting for a review, I suggest you jump on a quick call and discuss the changes together. Tip #4: Pair Programming The goal of a CR is to improve code quality, but there are other practices to achieve the same. One is pair programming. Pair programming consists of working together with a teammate on the same code. CR is unnecessary by the end of the work since at least 2 people have already viewed the code because they worked together. #SoftwareEngineering #CodeReview #CodeQuality #DevOps #ProgrammingTips #TechLeadership #AgileDevelopment #PairProgramming #SoftwareDevelopment #CodeCollaboration #DeveloperTips #EngineeringExcellence #TeamEfficiency #CodingBestPractices #TechProductivity

"🚀 Exploring Software Engineering Concepts! 🌐💻 Embracing Agile, OOP, and CI/CD for efficient development. Did you know about the SOLID principles and the power of refactoring? Let's foster a culture of continuous learning! 💡👨💼 1.Agile Methodology: Emphasizes iterative development, collaboration, and adaptability. Breaks projects into smaller, manageable tasks. 2.Object-Oriented Programming (OOP): A paradigm organizing code into reusable objects with properties and behaviors, promoting modularity and code structure. 3.Version Control: Enables tracking changes in codebase over time. Git is widely used for distributed version control. 4.Design Patterns: Reusable solutions to common problems in software design. Examples include Singleton, Observer, and Factory patterns. 5.Testing (TDD): Test-Driven Development involves writing tests before code, ensuring robust and bug-resistant software. 6.Continuous Integration/Continuous Deployment (CI/CD): Practices automating code integration, testing, and deployment, fostering quicker and more reliable development cycles. 7.SOLID Principles: Set of five design principles (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) promoting maintainability and flexibility in code. 8.Software Development Life Cycle (SDLC): The process of planning, creating, testing, deploying, and maintaining software systems. 9.Refactoring: Restructuring existing code without changing its external behavior to improve readability, maintainability, and performance. 10.Code Review: Collaborative process where developers assess each other's code for quality, adherence to standards, and potential improvements. #SoftwareEngineering #CodingCulture #TechInnovation"

How to Improve your Team's Code Quality through Better Feedback? 👀 Code Review improves the quality and maintainability of your code. However, it can be challenging for both engineering managers and developers. Below are a ways on how to provide effective Code Review feedback 👇 🔶 Encourage dialogues by asking questions rather than demanding changes. 🔶 Be clear and polite to prevent misunderstandings. 🔶 Focus on the code, not the developers. Address code issues objectively. 🔶 Clarify the reasoning behind your feedback. 🔶 Use 'I' statements. This helps in framing feedback as personal observations. 🔶 Provide improvement strategies and resources. 🔶 Share learning resources such as documentation and tutorials. 🔶 Keep reviews small. Break down large reviews into manageable parts. 🔶 Appreciate your developers. Include positive feedback. 🔶 Use automated Code Review tools to spot issues and ensure standards. #typo #codereview #codereviewtools #codereviewfeedback #softwaredevelopment

Can building and testing go hand in hand? Well, let's see. You can build new features while making sure everything works as it should, without putting off the deadline. It's like building a sturdy house – you want to make sure each brick is solid before you move on to the next one. > Get to Know What's Needed: Start by understanding what the new feature is supposed to do. Ask questions if anything is unclear. > Break It Down: Take the big task and break it into smaller, easier-to-handle parts. > Start with the Basics: Pick the most important bits and write tests for them first. This helps you focus on what really matters. > Try Test-Driven Development (TDD): If it makes sense to you, try writing tests that fail before you even start coding. It's like having a roadmap before you set off on a journey. > Build It Piece by Piece: Don't try to do everything at once. Take it step by step, writing code and tests as you go. > Clean Up as You Go: Once your tests are passing, take a moment to tidy up your code. It's like tidying your room – easier to find things later! > Check How Things Work Together: Write tests to make sure all the parts of your feature work well together. > Make Testing Easier: Automate your tests so you can run them with just a click. It saves time in the long run. > Test Often: Don't wait until the end to check if everything works. Test as you go to catch problems early. > Cover All the Bases: Think about what could go wrong and write tests for those situations too. > Get Some Feedback: Show your work to others to make sure you're on the right track. > Keep It Clear: Write your tests so that anyone reading them can understand what's going on. — 🧐 Don't mind me; I'm just an engineer laying out my thoughts on this digital canvas. ♻️ If you think more people need to hear this message, please give it a repost. #softwareengineering #programming #leadership

💡 Increasing code deployment speed🚀: Understanding the lifecycle of a commit As developers, mastering the art of shipping code fast is crucial for our growth and success. Early on, it lays the foundation for our entire career journey. In his latest newsletter, Ryan Peterman shares valuable guidelines for accelerating the speed of code shipping. https://lnkd.in/dA7Mtvjz Reflecting on his experience transitioning from Junior to Mid-Level, where autonomy and larger tasks became the norm, he realised the significance of 💡 rapid code deployment. 🔍 Understanding the lifecycle of a commit was key to optimizing the workflow. From design and coding to testing, review, and deployment, each stage demands attention and efficiency. 💡 Here are some insights Ryan Peterman gathered along the way: 🔧 Debugging Your Workflow: Identify where you spend the most time. For newcomers, focus on grasping the system's flow and mastering code tracing techniques. 🤝 Leverage Collaboration: Pair programming can be immensely beneficial, enabling knowledge transfer and quicker issue resolution. 🧪 Testing Strategies: Utilize feature flags, batch testing, and automation to streamline the testing process, minimizing risks and saving time. 📝 Effective Code Reviews: Write concise differentials, aim for fewer iterations, and guide reviewers with contextual comments to expedite the review process. 📈 Continuous Improvement: Prioritize enhancing your skills with each code deployment, aiming for same-day landings whenever possible. 🔄 The only element not entirely within our control is the code review timeline. If delays persist, initiating discussions with the team can foster a more efficient review process. Happy coding! #Coding #CodeDeployment #Deployment #CodeReview Image credentials: generated with Tengrai Artificial Intelligence

There was a time when you looked forward to coding.   You dedicated hours to IDEs, navigated through endless tasks, and awaited the occasional project that sparked a bit of excitement. Your potential became confined within team meetings, and your growth was gauged by code quality while you looked forward to a tiny raise. But now, things can change. You have skills that, when enhanced with the right guidance and strategies, can lift you to roles of significant impact and leadership. Yet, many talented engineers find themselves adrift, unsure of how to bridge the gap between technical expertise and influential leadership. For too long, the roadmap to get there has been scattered. No one has consolidated this under one banner. Until now. My new course, The Top Engineer Method, distills over 𝟮𝟬 𝘆𝗲𝗮𝗿𝘀 𝗼𝗳 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗮𝗻𝗱 𝗹𝗲𝗮𝗱𝗲𝗿𝘀𝗵𝗶𝗽 𝗲𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲 𝗮𝗰𝗿𝗼𝘀𝘀 𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁, 𝗬𝗮𝗵𝗼𝗼, 𝗖𝗮𝗿𝗻𝗲𝗴𝗶𝗲 𝗠𝗲𝗹𝗹𝗼𝗻, 𝗮𝗻𝗱 𝗧𝗮𝗵𝗮'𝘀 𝗠𝗲𝘁𝗵𝗼𝗱 into actionable lessons and strategies. Over the last 2 years, this method has already helped 40+ engineers move into higher roles with matching paychecks. Included are all the insights and tools you need to elevate your career to areas of autonomy, leadership, and innovation you’ve always aspired to reach. 𝗪𝗵𝗮𝘁 𝘄𝗶𝗹𝗹 𝘆𝗼𝘂 𝗹𝗲𝗮𝗿𝗻? My goal with The Top Engineer Method is to provide you with a comprehensive guide to transition from being a technical contributor to an impactful engineering leader. The course unveils a detailed framework for mastering complex problem-solving at the intersection of technology, business, and leadership. It includes navigating the intricacies of technical collaboration, wielding influence without authority, mentoring up-and-coming engineers, increasing your impact, and much more. If you want to be the kind of engineer or manager everyone respects, this is for you. I have an early enrollment discount. Sign up here -> https://lnkd.in/gCkggy-k