Ansible is a radically simple IT automation engine that automates cloud provisioning, configuration management, application deployment, intra-service orchestration, and many other IT needs. It can be used for advanced tasks such as continuous deployments or zero downtime rolling updates. Ansible is a push-based configuration management tool; it means we can push configuration onto the node machine directly without having any central node. It communicates with remote machines over SSH.The main goals of Ansible are ease-of-use and simplicity.
Feature of Ansible
• Simple and Ease-of-use
• YAML Based Playbook
In adopting a Shuhari strategy for their certification program, the Disciplined Agile Consortium has established a program which allows an individual to achieve measurable and incremental success (belts) that can be achieved using an iterative approach to their learning and practical experience.
Here is a summary of the stages
Shu (Learn) or beginning stage focuses on learning the basic techniques and philosophies of disciplined agile development. With a goal of achieving a White Belt and/or Yellow Belt
Ha (Detach) or intermediate stage is represented by Green Belt certification and is based on seeking to understand the range of strategies available to you and when they are best applied
Finally, Ri (Transcend) is the “master” stage, is represented by the Disciplined Agilist-Black Belt certification, is where you are consistently sharing your learning with others.
Here are the DAD consortium has established four certification levels:
Recently read a good article on adopting “Continuous Delivery practices”. In the white paper, “Adopting IBM’s approach to continuous software delivery,” the author, Paul Bahr discussed IBM’s adoption framework for iteratively introducing new capabilities and planning improvements.
In the our-part blog series that outlined a good four-step process for getting started on your improvements journey (step 1, step 2, step 3 and step 4). The author also discussed that the first steps for planning your DevOps adoption was to take a
Earlier this month during the 2014 IBM Innovate Conference, I delivered a 1-hour seminar on scaling agile planning to support large programs. If you didn’t get to travel to Florida for the conference, here is the session material for you to review.
Many organizations have embraced agile practices such as only Scrum and eXtreme Programming (XP), only to discover that while these practices provide great benefit to individual development teams, they don’t always scale when used at the project or program levels.
In this session, we explore real-world challenges and discuss how some of organizations have used practices from other agile methodologies such as Disciplined Agile Delivery (DAD) and Scaled Agile Framework (SAFe), to successfully scale to these levels
Now let’s take a look at the Scrum framework. Scrum is the best known and most widely adopted agile framework in the world today. With its emphasis on delivery high quality solutions faster and continuous improvement, Scrum teams value commitment, openness, and respect.
Agile teams respond to change by focusing on the customer’s immediate needs and by not doing anything that is not required immediately. The Product Owner, the person that best represents the customer, selects the stories (or feature) that provides most valuable to the customer, and the whole team works on that feature.
Agile is about delivering software as soon as possible, and then regularly and frequently. Scrum teams focus on working on valuable tasks each day until the PO is satisfied.
Rapidly responding to change and delivering in short intervals is often the most challenging part of adopting agile for those people who have spent most of their careers working with a traditional or waterfall method.
In addition, agile is about enjoying your work. Agile team are self-organizing, meaning the team, and everyone on it, is empowerment to make decisions that would otherwise be made by the project manager. For example agile teams estimate their own work, work with the PO to decide which stories are prioritized for delivery.
Finally, Agile is about using the knowledge, ideas, and inspiration of everyone in the company. Agile teams take time out to reflect on the recent past and to identify ways removing blocks or impediments to producing high quality code.
Contrary to popular opinion, not every IT project can successfully adopt agile practices. Location of resources, team structure, corporate culture and even technology used, can all play a key factor in determining which development practices will work in an organization. While many companies are actively seeking to use agile practices, such as XP or Scrum to help streamline production with fast, effective development practices that can give their customers what they want in the shortest time possible, elements of some of the traditional software development methods such as the “Waterfall” or “Rational Unified Process (RUP)” are often required to bridge the gaps that some of these new practices have. In the end, most organizations must adopt a blended approach that bests fits their software project, business culture, and development environment.
In this blog, I compare the strengths and weakness of some of the traditional software development practices – Waterfall and RUP – along with providing guidelines for adopting them. In a subsequent blog will compare these process to agile practices.
The traditional software development process, is often referred to as “Waterfall”, is a highly structured and sequential process that relies heavily on up-front planning and prescribed tasks that flow from one to another like a waterfall. Typical phases in a project using Waterfall development are shown below.
Each phase usually requires its own set of subject matter experts (SME) responsible for creating the deliverables (requirements documents, design document, test plans, detailed designs, etc…) to meet carefully scripted milestones. In Waterfall, the next phase typically cannot be started until the previous one has been completed. The goal is to gather and analyze all the detailed requirements early in the process so that a complete solution can be architect-ed and build with highly predictable results.
Waterfall development can work well for complex or mission-critical systems or for and for organizations that require the highest levels of fault tolerance (such as the military or aerospace). However, projects using Waterfall processes take too long, in many cases months or years, to produce results that can be verified by the user and often and lacks the flexibility for today’s environment. In addition, because Waterfall projects require that all the requirements be defined upfront (often referred to as Big Up Front Requirements – BUFR), these projects often do not provide business value in today’s fast-paced software market as in many cases requirements changes result in expenses change requests or buggy systems.
Rational Unified Process
The Rational Unified Process® is a Software Engineering Process. It provides a disciplined approach to assigning tasks and responsibilities within a development organization. Its goal is to ensure the production of high-quality software that meets the needs of its end-users, within a predictable schedule and budget. RUP is “use-case driven, architecture-centric, and incremental and iterative”.
Software projects that use RUP divide the project time-line into four consecutive phases.
Inception, where the project’s scope, estimated costs, risks, business case, environment and architecture are identified.
Elaboration, where requirements are specified in detail, architecture is validated, the project environment is further defined and the project team is configured.
Construction, where the software is built and tested and supporting documentation is produced.
Transition, where the software is system tested, user tested, reworked and deployed.
Each phase is concluded with a well-defined milestonee—a point in time at which certain critical decisions must be made and therefore key goals must have been achieved. Iterations occur in each phase. Activities in iterations are focused on one of the four activities: gathering requirements, analyzing, designing, implementing, and testing. Each of these activities place a more or less important role as the project moves from phase to phase.
RUP also defines the roles and activities of team members in-depth and relies at each stage on the production of visual models, which are rich graphical representations of software systems, and specific use cases rather than the large amounts of documentation required for each stage of Waterfall. All team members have access to the same large knowledge base of guidelines, templates, tools, and other items to ensure that they share the same language and perspective on the project.
Proponents stress that it enhances team productivity by providing each team member with guidelines, templates and tool mentors for all critical development activities. While critics consider it to be too heavy, sighting the large number of documents and other artifacts that must be created to successfully adopt RUP properly. Also while RUP is an iterative approach, the Inception and Elaboration, still provide plenty of opportunity for BUFR to be produced and the remaining development cycles follow somewhat of a waterfall approach to code development and doesn’t stress the need to produce working code as fast as possible.
RUP has been around for 20+ years and has evolved into a proven software development method that has been used by many different teams in many different situations. It is easy to find resources and skills and has many advantages over traditional waterfall approach
Work items are the fundamental mechanism in Rational Team Concert (RTC) used to coordinate, and track development tasks. RTC provides several out-of-the-box work items types including Epic, Story, Task and Defect. Each work item has its own workflow and associated set of attributes used to govern progress status, reporting and collaboration. Work items are the hub for linkage between many Rational Team Concert artifacts (e.g. other work items, builds, work items, and change sets), as well as providing support for integration with other products.
While RTC allows teams to link work items in any manner they choose, to keep it simple in when the customer is using the SCRUM Process Template, several of my customer implementation, I have recommended the following work item hierarchy: Epic story->Story -> Task/defect, see figure below.
User stories are a good approach to capturing customer requirements without having to create formalized requirement documents or incurring the extra effort to maintaining them. The intention is to speed up the requirement definition process, respond faster to changing requirements and communicate requirements in the language of the customer using scenarios that can be easily validated.
By default the RTC Scrum process template, Epics Stories are defined as top-level-item while Tasks are not. Each Story can be broken down into smaller tasks but it is not required. In addition we recommend that the RTC process template be updated to make the Defect a top-level-item.
Finally, RTC allows team to use the Work Item customization to create new work item types or modify existing ones in order to support the development process that your team follows. For additional information see Work item tracking on Jazz.net.