What's the best way to optimize your code in SDLC?

For smooth SDLC detail planning and regular (Daily/weekly) connects and updates from all stakeholders is important part, key to successful delivery of SDLC is timely communication, set scope and expectation at the right time, understand and mitigate the risk at right time. Keep all stakeholder informed about there roles and responsibility. In todays world can use DEV/OPS, Agile methods, PMP best practices as per applicable project using SDLC.

Having a great depth of client requirements will give you avenues to build features that add value to customers and also tight down to the overall goal objective of the organization. This also positioned you to deliver faster because you already understood client needs and problems.

We can enable use of AI in understanding user requirements in the Software Development Life Cycle. AI-powered NLP models can analyse and extract valuable insights from user-provided textual information, such as emails, feedback, and requirements documents. This enables the system to identify key user needs and preferences. AI can perform sentiment analysis on user feedback to gauge user satisfaction and identify pain points. This helps prioritize requirements that address user concerns. AI-driven analytics tools can track and analyse user interactions with existing software to uncover usage patterns and preferences. This data can inform requirements for enhancements or new features

Use the right algorithms and data structures to optimize your code. Choosing the right algorithms and data structures can have a big impact on the performance of your code. Refactoring can help to improve the readability, maintainability, and performance of your code. Any code that is not needed should be removed. This can help to improve the performance and readability of your code. Comments can help to explain the purpose of your code and make it easier to understand. A linter or code analyzer can help you to identify potential errors and inefficiencies in your code. Testing your code can help you to identify and fix any errors or bugs.

Understand Requirements clearly and document them properly in test cases as per the acceptance criteria, positive & negative and edge-cases (including boundary values, equivalence partitioning, etc.) scenarios. Use BDD for automation and code your testing scripts with desired programming language standards. Also, work on parallel executions to save time and auto re- executions of fail tests (even failed in parallel execution) to avoid intermittent downtime or cloud machine instability failures in any cloud blade. Have a proper CI/CD configuration of your tests. This will save time and money in huge sets of automation testing executions.

It is crucial to determine the tech stack and type of storage our project requires. Initially, selecting the right framework and language is essential, but more importantly, choosing the appropriate performance tools is important for optimizing critical code paths in the functionality, significantly improves execution time. If the application heavily relies on a database, it is essential to consider the right database optimization tools to enhance query performance, indexes, complex aggregations, and schema design. Additionally, implementing effective caching strategies will significantly improve performance. Ultimately, the specific tools we choose depend on our requirements, and selecting them correctly will help optimize our code.

It’s always great to determine if there is the right architecture to build functionality or features. Choosing the right tools and technology not only make you deliver result incrementally but also make it easier for teams to learn grow and develop expertise in using them.

In this context, it is important to consider the engineering teams who will be operationalizing or maintaining the tech stack over time. Given the tech choices, will we have sufficient capability to support it, to evolve it? Will we be choosing a proprietary solution that offers speedier and ease of implementation, at the expense of costly add-on customisation and consultation later on? Do all your stakeholders have buy-in on these decisions? How will our decisions today impact the underlying data and interoperability? I would also recommend further reading on Cross-Functional Requirements, or NFRs, to guide your decision-making processes.

we can harness AI's analytical capabilities, development teams can make more informed decisions when selecting tools and technologies for the SDLC. AI can process vast amounts of historical project data, including project outcomes, resource utilization, and technology choices. By analysing this data, AI can identify patterns and correlations between technology selections and project success, helping teams make informed decisions. AI can analyze project requirements and compare them to the capabilities of different tools and technologies. This ensures that the chosen solutions align with project goals and constraints.

AI can match project requirements with suitable tools and technologies, ensuring alignment with project goals and constraints in software development decision-making.

Following coding best practices is key. Create a framework with interfaces. Implement these interfaces in helper methods. Reuse these methods everywhere possible. This way, we will not end up writing the same code multiple times. Also, reusing methods, facilitates consistency in business logic. Consider the case, that a certain business rule always be tested before saving to database. If this has to be done in multiple areas of the code, then, it's best we have a dedicated method for this. This is also a cleaner approach when multiple developers work on the team. Refactoring logic in one method is easier when compared to figuring out all areas of impact and rewriting these changes multiple times. Code maintenance is also easier this way!

Following most of the Standards and Convention is mundane in nature and can largely be automated using AI. AI tools can analyse codebases, detect deviations from coding standards, and provide real-time feedback to developers. AI can automatically format code according to predefined style guidelines. AI can generate code documentation, ensuring consistency and completeness. AI-driven suggestions can help developers refactor code to align with standards. AI-powered linters and static analysers can identify code violations and suggest corrections. AI can offer coding standard training and guidance to developers, promoting compliance.

Adhering to coding best practices, especially through the creation of a framework with interfaces and reusable helper methods, is essential for developing high-quality software. A well-structured framework built around interfaces provides a blueprint for consistent code implementation. Interfaces define contracts that enforce a standardized approach to handling common functionalities, ensuring that developers adhere to established coding standards. By implementing these interfaces in helper methods, developers can efficiently reuse code throughout the project, eliminating redundancy.

There are various tools and technologies (many open source with active community support) will enable such quality and most importantly shift left quality. With such an approach, review and approval cycles are also shorter. Some organisations also adopted enterprise wide templating methods as well which help in regulatory compliance from a change management perspective. Change metrics as defined by DORA (high deployment frequency and/or change lead time), embedding automated checks (pre/post-commit/PR/MR) ensures the right quality of documentation.

It's not just a matter of the team following these standards; the SDLC itself can enforce these with CI/CD pipeline tools and checks. For instance, code can be automatically formatted upon commit, or a PR "failure" condition can be triggered by improperly-formatted code.

I have used a combination of the below techniques, and it works. 1. Refactoring the code (Usage of tools) 2. Align to the best practices of design patterns (SOLID). Usage of interfaces, create libraries that can be used across projects. 3. Knowledge sharing and communication within the team. This will ensure team member is not rewriting the same code that another team member has written. 4. Running static code and dynamic code analysis regularly 5. Making sure that code reviews happen with peer and leads. 6. Make sure every class releases resources. (ex: releasing memory allocated to pointers) 7. Include Performance testing as part of development and not as a separate Testing phase after completion of development.

SDLC is applicable in IT/OT Operations/Site Reliability Engineering (SRE) and focusing on Infra-As-Code (IaC), in general and broadly adopted principle is DRY. I always applied this and this has yielded fantastic results in small/medium/large enterprises across various industry verticals (telecom, healthcare, banking, insurance, retail, cpg, energy & utilities).

Adding to the list here: TDD, BDD, CI/CD. Many of the XP (extreme programming) values and principles apply here. You should consider factors such as centralised decisioning vs local optimisation.

We should exploit automated testing tools and frameworks that beat suit our Applications tech stack to ensure effective checks are done and vulnerabilities are captured early in the game.

See testing not as an after-thought, but Quality Assurance from the very beginning, aka, Shift-Left movement. “Don’t write a hacky-job today, that will become tomorrow’s legacy code!”

Code documentation isn't necessarily the "final" step - it should be done throughout the process. Documentation shouldn't also simply restate the code in natural language, but rather explain why certain design decisions were taken. Sometimes, those decisions may not be obvious when the work is completed, so they should be captured throughout the process.

Quality documentation of code in a continuous fashion is an important aspect which ensures not only maintainability, interpretability but also ensures reflection of clarity of requirements -> design -> code -> test and maintain. Documentation should also align with designs (architecture & solution) created in the initial stages of the cycle. Standards of documentation should be created, maintained and followed. In certain cases where change metrics as defined by DORA (like high deployment frequency and/or low change lead time), embedding automated checks (pre/post-commit/PR/MR) ensures the right quality of documentation.

The great Donald Knuth said "premature optimisation is the root of all evil" - by this he infers that you can spend a lot of time optimising the wrong thing. For example, if the database call takes 5 seconds and the business logic that runs on the returned data takes 1 second - maybe look at the database call first before trying to optimise the business logic code.

Optimized code in your SDLC on its own, in a vacuum, does not always equate to good software, even if it is always with good intent. WORKING Software is a first step in achieving that, and whatever you are building need to deliver value. In other words, does it actually solve the problem you are trying to address? How do you know when you have done that? The SDLC does not end at this point, though. Think about how this code will be refactored and extended, and eventually decommissioned.

How many of you obsess over code optimization like compiler engineers? In many cases, sloppy code and its optimized counterpart will compile down to the exact same bytecode. Excessive focus on performance tweaks may be overkill. Instead, prioritize clean, maintainable code using established best practices. Concentrate on the essentials: does it work correctly? Will it scale under load? Once you've got those right, move on! AI-powered code assistants (like DEVIN) can help with revisions if you want. Of course, memory leaks and bottlenecks will sometimes happen. Tackle them as they become real issues. Proactive solutions are better, so investing in skilled architects to design robust systems can prevent some problems from the start.

For my fellow Product Managers, a few thing I’ve learned (and still learning) are: - Don’t be afraid to prioritize tech debt stories in your backlog. - Schedule code refactoring in at the time your team pulls in a story into the sprint. Make sure you schedule in more testing time when predicting your production release date. - Listen to your Solutions Designer/Architect. Work closely with her to understand the importance of keeping your code in tip top shape!