Here is our monthly selection of knowledge on programming, software testing and project management. This month you will find some interesting information and opinions about roadmapping, Devops, test cases, leadership, quality gates, Contract-First Software Development, Java performance testing, technical debt and Android open source testing tools.
Text: The Fundamentals of Roadmapping Measuring performance and holding leaders accountable is indeed important, but what’s often missing is the holistic view of where the company is going and an organization-wide understanding of how it will reach its goals. Before setting those metrics, leaders must be clear about the True North for the business — the compass of your company’s identity and growth direction — and set a near-term vision with a roadmap to get there.
Text: DevOps tech: Empowering teams to choose tools If you want to achieve higher software delivery performance and increase the job satisfaction of your technical staff, you should empower them to make informed choices about the tools and technologies they use to do their work. Research from the DevOps Research and Assessment (DORA) team shows this contributes to better continuous delivery and higher software delivery performance. Teams that can choose their own tools are able to make these choices based on how they work and the tasks they need to perform. No one knows better than practitioners what they need to be effective, so it’s not surprising that practitioner tool choice helps to drive better outcomes.
Text: The work-centric standup When done well, standups are a highly effective tool to keep work progressing in the right direction. In this post, I’ll talk about my experience with a different standup format than the one most commonly used. A format I think does a much better job of accomplishing the intended goal of standups in the first place.
Text: Comparing Test Cases and Acceptance Criteria Test cases and acceptance criteria are two important aspects of test management. In this article, Ovidiu Donciu discusses the similarities and differences between test cases and acceptance criteria and suggests that we could merge them.
Text: Software Engineering Leadership is not (Only) About Coding Well This post is for those confident and independent engineers that are used to being effective in code-bases, that are able to execute, that find themselves taking responsibilities and holding them close. These engineers might be on the path of being blocked by their inability to understand how growing the environment is critical to growing ourselves.
Text: Reducing Product Risk and Removing the MVP Mindset What is the right way to build products? Earlier in my career, I would have told you everything should be AB tested, and that you should build only as little as you need to validate a hypothesis. Every problem should have user research involved at the beginning, aligned on the problem instead of just validating or invalidating solutions. Every key result should be outcome based. Every engineer, designer and product manager on the team should be involved in defining the problem and the solution. These are all good ideas. However, once you add enough of these “best practices” up, it reads kind of like those articles talking about the morning habits of the most successful people in the world. If you actually try to follow all of those habits, it would take you six hours a day and cost a lot of money. I was once reading an article about what a futurist at Google eats for breakfast every morning to live longer. The article added up that his diet of food and pills cost him $1 million per year. My morning ain’t that long, and I ain’t got that much money.
Text: Software Quality Gates (QGs): Automated Code Tests Quality Gates (QGs) are special automatic product quality checks that should set software quality thresholds for the “movement” of code along the virtual software development pipeline. In this article, we analyze Quality Gates as a technique for software quality assurance, and also propose a roadmap to implement them in your software development projects.
Video: Why You Should Be Doing Contract-First Software Development You’re adopting “DevOps” and “Microservices” because of the promise of delivering value faster to your users/customers. But you are not seeing the gains you want to see. You’ve got CI/CD/Pipelines/Tests/Microservices/etc. But you are still getting bogged down with teams being dependent on the progress of each other. Service A isn’t done, so service B cannot work on integration. The UI requires access to ALL of the services, so it has to wait until the end to be integrated, and integration takes WEEKS because of back-and-forth issues between the frontend and backend and between different dependent services. This is NOT how this is supposed to work!
Video: Performance Testing Java Applications Every so often, you will read a performance benchmark (of a Java or other language application), with bold claims for how well X performs compared to Y. Testing the performance of your Java application is more an art form rather than engineering, and is a minefield of misconceptions, misunderstanding, and misinformation. This presentation reviews the basics of performance testing and give you concrete steps to build a robust performance testbed for your application.
Video: Refactoring the Role of Software Architects This presentation takes you through a journey to explore some software architecture principles, forged through practice from real-world projects. You will learn strategies for mentoring development teams, scaling processes, and maximizing efficiency. With the right structures in place, software architects can guide teams into the “pit of success,” as Scott Guthrie likes to put it. Together, we’ll strike down the walls of the ivory tower and raise up a new group of evolutionary architects. We want to make sure architects are viewed as peers and not as 10xengineers.
Video: Communicating Intention with Functional TypeScript We spend a lot of our time reading TypeScript code for many different reasons, code that may have been written by yourself or someone else. So why not do our future selves and colleagues a favor and write TypeScript code that at a glance will communicate what it’s doing? And while doing that, let’s leverage what TypeScript has to offer as well as some good functional programming practices. In the end, we want to spend less time trying to understand some “clever” code or uncover some hidden surprises and more time shipping value to our clients.
Video: A Framework for Managing Technical Debt Technical debt is inevitable in Agile software development and rewriting your code every 6 months is not an option. Refactoring is a complex topic that doesn’t have a one-size-fits-all solution. Frontend applications are particularly sensitive because of frequent requirements and user flows changes.
Video: Testing Pyramid Makes Little Sense The testing pyramid – the canonical shape of tests that defined what types of tests we need to write to make sure the app works – is … obsolete. In this presentation, Roman Sandler and Gleb Bahmutov argue what shape works better for testing web applications.
Video: Project Management: Waterfall, Agile & Hybrid Approaches This video outlines three main approaches to software development project management: Waterfall, Agile and Hybrid. When planning and executing a project, it is important to make sure you are using the appropriate Project Management methodology to best meet your project objectives.
Tools: Open Source Android Testing Tools The shift towards mobile platforms is a strong trend currently and Android is the most widely adopted mobile OS with an estimated market share above 80% in 2014. You should naturally test all the apps developed for Android and a large number of open source testing tools and test automation frameworks have been developed to achieve this goal.
Tools: Commercial Scrum Online Retrospectives Tools Many Scrum teams are based on a distributed organization where members are in different locations, countries or time zones. How could these Agile teams perform their retrospectives? Some companies have developed online tools that can be used to facilitate retrospectives for distributed Scrum teams
Tools: LambdaTest – Cloud-Based Platform For All Testing Needs. LambdaTest is a cloud-based platform that caters to all your automation and manual testing needs without owning any device physically. LambdaTest provides web application testing, mobile web, and native app testing with an option to choose from emulators or actual devices. In addition to usual web and app testing, the tool allows a list of integrations, making it a unified solution with all the necessary features for a tester.