Downloaded 13 times
Uploaded byLean Apps
DevOps at Lean Apps
DevOps is a culture that integrates development and operations teams throughout the service lifecycle, emphasizing communication, collaboration, and automation. Key practices include unit testing, code quality checks, and notifications, which improve software stability and efficiency while empowering teams. The benefits of DevOps include faster delivery, increased innovation, and a strong focus on collaboration among team members.
More Related Content
DevOps at Lean Apps
- 1. DevOps What ? Why? Who ? How ?
- 2. What is DevOps? DevOps is the culture of Development and Operations Engineers, participating together in the entire service lifecycle, from design through the development process to production support. DevOps is a software development method that stresses communication, collaboration and integration between software developers and information technology (IT) operation professionals.
- 3. What actually isit ? DevOps is the umbrella term for the practice which encompasses - ➔ Culture Cross-Team collaboration. ➔ Automation Automating repetitive tasks. ➔ Monitoring Monitoring systems, apps, etc. ➔ Sharing Sharing reports, issues, regarding code, system, application, etc.
- 5. DevOps Process Flowat Lean Apps
- 6.
- 7.
- 8. CSS LINT Unit TestingCode Quality Check Notifications Archive
- 9. Unit Testing Unit Testingis a level of software testing where individual units/ components of a software are tested. The purpose is to validate that each unit of the software performs as designed. ➔ Benefits ◆ Unit testing increases confidence in changing/ maintaining code. ◆ Easy to catch any defects introduced due to the change
- 10. Code Quality Check CodeQuality Check helps us deliver higher quality software and fix critical security issues in our applications. ➔ Benefits ◆ Quantifies the quality of your code. ◆ Metrics that tell useful things about source code. ◆ Trace through the code paths and quickly find subtle bugs that would take a human forever to track down. CSS Lint
- 11. Notifications Notifications play amajor role in the DevOps process flow. Notifying the developers/QA/Scrum Masters about builds, code quality and deployments is very crucial. ➔ Benefits ◆ Build and Code quality reports are sent via notifications. ◆ Stakeholders know the quality and efforts in development. ◆ QA know when a new build arrives.
- 12. Artifacts Generating artifacts fordeployment ends the Integration cycle. ➔ Benefits ◆ Generates a ready-to-deploy object in the form of : ● WAR (Java Projects) ● ZIP(PHP Projects) ● APK(Android Projects) ● IPA(iOS Projects).
- 13.
- 15. Benefits and Powerof DevOps 1. Agility 2. Velocity - Faster Delivery 3. Continuously incorporating Feedbacks. 4. Visibility to Build, Run and Secure Modern Applications 5. Innovation 6. Software Stability and Quality 7. More time to innovate (rather than fix/maintain). 8. Team Empowerment/Communication/Collaboration. 9. Increased Effectiveness. 10. Customers/Clients/Employers love DevOps. 11. Zero blame shifting, and more of owning of responsibility.
- 16. Collaboration ➔Collaboration is themost important part of DevOps. ➔Dev and Ops work best when they work in a collaborative manner as defined by DevOps. ➔It is the key to success.
- 17.
- 18. What people aresaying ?
- 21. What Lean Appspeople are saying Build flavours in Android generate environment specific builds efficiently in Jenkins. Another benefit is learning about DevOps & automation. Saurabh Sircar, Full Stack Mobile Dev Saved us a lot of time with automation, and build reports make it very easy for us to locate errors, if any. And learning is the best part. Prajwal Thakre, Java Dev Code validation from Unit Tests gives us a sense of confidence about our code, and metric reports show us the exact quality of our code. Chandrakant S., Java Dev Automated notifications about Builds is one of the best things for me. Apart from this, a lot of time is saved from Dev’s end as well as QA’s. Niraj Gahukar, QA
- 22. BY: Yash Shanker DevOps atLean Apps QUESTIONS ?
Editor's Notes
- #10 A unit is the smallest testable part of software. Testing each unit with mock inputs is Unit Testing. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse. Development is faster. How? If you do not have unit testing in place, you write your code and perform that fuzzy ‘developer test’ (You set some breakpoints, fire up the GUI, provide a few inputs that hopefully hit your code and hope that you are all set.) If you have unit testing in place, you write the test, write the code and run the test. Writing tests takes time but the time is compensated by the less amount of time it takes to run the tests; You need not fire up the GUI and provide all those inputs. And, of course, unit tests are more reliable than ‘developer tests’. Development is faster in the long run too. How? The effort required to find and fix defects found during unit testing is very less in comparison to the effort required to fix defects found during system testing or acceptance testing. The cost of fixing a defect detected during unit testing is lesser in comparison to that of defects detected at higher levels. Compare the cost (time, effort, destruction, humiliation) of a defect detected during acceptance testing or when the software is live. Debugging is easy. When a test fails, only the latest changes need to be debugged. With testing at higher levels, changes made over the span of several days/ weeks/ months need to be scanned. Codes are more reliable. Why? I think there is no need to explain this to a sane person. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse. Development is faster. How? If you do not have unit testing in place, you write your code and perform that fuzzy ‘developer test’ (You set some breakpoints, fire up the GUI, provide a few inputs that hopefully hit your code and hope that you are all set.) If you have unit testing in place, you write the test, write the code and run the test. Writing tests takes time but the time is compensated by the less amount of time it takes to run the tests; You need not fire up the GUI and provide all those inputs. And, of course, unit tests are more reliable than ‘developer tests’. Development is faster in the long run too. How? The effort required to find and fix defects found during unit testing is very less in comparison to the effort required to fix defects found during system testing or acceptance testing. The cost of fixing a defect detected during unit testing is lesser in comparison to that of defects detected at higher levels. Compare the cost (time, effort, destruction, humiliation) of a defect detected during acceptance testing or when the software is live. Debugging is easy. When a test fails, only the latest changes need to be debugged. With testing at higher levels, changes made over the span of several days/ weeks/ months need to be scanned. Codes are more reliable. Why? I think there is no need to explain this to a sane person.
- #11 A unit is the smallest testable part of software. Testing each unit with mock inputs is Unit Testing. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse. Development is faster. How? If you do not have unit testing in place, you write your code and perform that fuzzy ‘developer test’ (You set some breakpoints, fire up the GUI, provide a few inputs that hopefully hit your code and hope that you are all set.) If you have unit testing in place, you write the test, write the code and run the test. Writing tests takes time but the time is compensated by the less amount of time it takes to run the tests; You need not fire up the GUI and provide all those inputs. And, of course, unit tests are more reliable than ‘developer tests’. Development is faster in the long run too. How? The effort required to find and fix defects found during unit testing is very less in comparison to the effort required to fix defects found during system testing or acceptance testing. The cost of fixing a defect detected during unit testing is lesser in comparison to that of defects detected at higher levels. Compare the cost (time, effort, destruction, humiliation) of a defect detected during acceptance testing or when the software is live. Debugging is easy. When a test fails, only the latest changes need to be debugged. With testing at higher levels, changes made over the span of several days/ weeks/ months need to be scanned. Codes are more reliable. Why? I think there is no need to explain this to a sane person. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse. Development is faster. How? If you do not have unit testing in place, you write your code and perform that fuzzy ‘developer test’ (You set some breakpoints, fire up the GUI, provide a few inputs that hopefully hit your code and hope that you are all set.) If you have unit testing in place, you write the test, write the code and run the test. Writing tests takes time but the time is compensated by the less amount of time it takes to run the tests; You need not fire up the GUI and provide all those inputs. And, of course, unit tests are more reliable than ‘developer tests’. Development is faster in the long run too. How? The effort required to find and fix defects found during unit testing is very less in comparison to the effort required to fix defects found during system testing or acceptance testing. The cost of fixing a defect detected during unit testing is lesser in comparison to that of defects detected at higher levels. Compare the cost (time, effort, destruction, humiliation) of a defect detected during acceptance testing or when the software is live. Debugging is easy. When a test fails, only the latest changes need to be debugged. With testing at higher levels, changes made over the span of several days/ weeks/ months need to be scanned. Codes are more reliable. Why? I think there is no need to explain this to a sane person.
- #12 A unit is the smallest testable part of software. Testing each unit with mock inputs is Unit Testing. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse. Development is faster. How? If you do not have unit testing in place, you write your code and perform that fuzzy ‘developer test’ (You set some breakpoints, fire up the GUI, provide a few inputs that hopefully hit your code and hope that you are all set.) If you have unit testing in place, you write the test, write the code and run the test. Writing tests takes time but the time is compensated by the less amount of time it takes to run the tests; You need not fire up the GUI and provide all those inputs. And, of course, unit tests are more reliable than ‘developer tests’. Development is faster in the long run too. How? The effort required to find and fix defects found during unit testing is very less in comparison to the effort required to fix defects found during system testing or acceptance testing. The cost of fixing a defect detected during unit testing is lesser in comparison to that of defects detected at higher levels. Compare the cost (time, effort, destruction, humiliation) of a defect detected during acceptance testing or when the software is live. Debugging is easy. When a test fails, only the latest changes need to be debugged. With testing at higher levels, changes made over the span of several days/ weeks/ months need to be scanned. Codes are more reliable. Why? I think there is no need to explain this to a sane person. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse. Development is faster. How? If you do not have unit testing in place, you write your code and perform that fuzzy ‘developer test’ (You set some breakpoints, fire up the GUI, provide a few inputs that hopefully hit your code and hope that you are all set.) If you have unit testing in place, you write the test, write the code and run the test. Writing tests takes time but the time is compensated by the less amount of time it takes to run the tests; You need not fire up the GUI and provide all those inputs. And, of course, unit tests are more reliable than ‘developer tests’. Development is faster in the long run too. How? The effort required to find and fix defects found during unit testing is very less in comparison to the effort required to fix defects found during system testing or acceptance testing. The cost of fixing a defect detected during unit testing is lesser in comparison to that of defects detected at higher levels. Compare the cost (time, effort, destruction, humiliation) of a defect detected during acceptance testing or when the software is live. Debugging is easy. When a test fails, only the latest changes need to be debugged. With testing at higher levels, changes made over the span of several days/ weeks/ months need to be scanned. Codes are more reliable. Why? I think there is no need to explain this to a sane person.
- #13 A unit is the smallest testable part of software. Testing each unit with mock inputs is Unit Testing. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse. Development is faster. How? If you do not have unit testing in place, you write your code and perform that fuzzy ‘developer test’ (You set some breakpoints, fire up the GUI, provide a few inputs that hopefully hit your code and hope that you are all set.) If you have unit testing in place, you write the test, write the code and run the test. Writing tests takes time but the time is compensated by the less amount of time it takes to run the tests; You need not fire up the GUI and provide all those inputs. And, of course, unit tests are more reliable than ‘developer tests’. Development is faster in the long run too. How? The effort required to find and fix defects found during unit testing is very less in comparison to the effort required to fix defects found during system testing or acceptance testing. The cost of fixing a defect detected during unit testing is lesser in comparison to that of defects detected at higher levels. Compare the cost (time, effort, destruction, humiliation) of a defect detected during acceptance testing or when the software is live. Debugging is easy. When a test fails, only the latest changes need to be debugged. With testing at higher levels, changes made over the span of several days/ weeks/ months need to be scanned. Codes are more reliable. Why? I think there is no need to explain this to a sane person. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse. Development is faster. How? If you do not have unit testing in place, you write your code and perform that fuzzy ‘developer test’ (You set some breakpoints, fire up the GUI, provide a few inputs that hopefully hit your code and hope that you are all set.) If you have unit testing in place, you write the test, write the code and run the test. Writing tests takes time but the time is compensated by the less amount of time it takes to run the tests; You need not fire up the GUI and provide all those inputs. And, of course, unit tests are more reliable than ‘developer tests’. Development is faster in the long run too. How? The effort required to find and fix defects found during unit testing is very less in comparison to the effort required to fix defects found during system testing or acceptance testing. The cost of fixing a defect detected during unit testing is lesser in comparison to that of defects detected at higher levels. Compare the cost (time, effort, destruction, humiliation) of a defect detected during acceptance testing or when the software is live. Debugging is easy. When a test fails, only the latest changes need to be debugged. With testing at higher levels, changes made over the span of several days/ weeks/ months need to be scanned. Codes are more reliable. Why? I think there is no need to explain this to a sane person.
- #16 strategic imperative becomes responding rapidly via agility and modularity through DevOps and adaptive IT. When you don't know what the future holds, it's important to have the infrastructure in place that can respond to business needs on the fly. Speed to market and quick iteration is critical in competing in software, otherwise competitors will outpace your product development and win the market. To compete, engineering teams should adopt DevOps to enable teams and break down friction in order to increase agility and speed to market. Surveys have shown that organizations successfully implementing DevOps tools and practices are likely to experience high growth in profitability, market share, and productivity goals
- #20 Author of NextGenDevops ...
- #21 Co-Founder DevOpsGuys and MS Regional Director