Software development Life cycle (SDLC) is a process of producing high-quality software at the lowest cost and in possibly less time. Generally, SDLC has well-tested and ready-to-use phases which provide an organization to help in creating high-quality software. ISO/IEC 12207 is an international standard of software life cycle process. This standard defines all the tasks which need to develop and maintain software. SDLC targets to produce high-quality software by meeting the expectations of clients within the time limit and in budget. It is made up of a plan which describes how to develop, maintain, alter, and improve the software.

Why we need SDLC

Basically, SDLC is a method with the process, which helps in creating high-quality software. By this you can understand the whole criteria of producing effective software, that’s why SDLC is important. Without SDLC you can’t create a standard software because it gives a standard way to produce an effective and efficient software that will run in the market with client expectations which will help him in managing his part of work. With time we update the software as per customer feedbacks to get a better result which is also a part of SDLC.

Benefits of the Software Development Lifecycle

• Forms the base for project planning.
• Helps to estimate cost and time.
• It gives the clarity of the project and the development process.
• Enhance the speed and accuracy of development progress.
• Minimizes the risks and maintenance during the project.
• Its given standard improves client relations.
• SDLC implement checks to ensure that the software is well tested before being installed in greater source code
• Developers can’t move to the next step until the prior one is completed by SDLC.

What are the SDLC phases

Software Development Life Cycle Models

Waterfall Model:-

A little too old and harsh model is the Waterfall model. It is one of the old-fashioned SDLC models that is not much preferred in the modern software development ecosystem.

The reason it is not favored much is that it runs on a very inflexible structure conditioning that the entire set of requirements should be laid down from the very beginning of a project. This limits the freedom and flexibility of the actual design and development of software.

After completing the development, the product goes through the test for meeting its initial requirements. If it is not good enough, it is to be restructured, which is a lot of work.

Usually, software development companies resist dealing with Waterfall though it still seems to be an effective model for the handful of projects.

RAD Model:-

The rapid Application Development (RAD) process is an adoption of the waterfall model. It aims to developing software in a short period. The RAD model is based on prototyping and iterative development with no specific planning involved. The process of writing the software itself involves the required planning for developing the product. The RAD model is based on the concept that a better system can be developed in less time by using focus groups to collect system requirements

• Business Modeling
• Data Modeling
• Process Modeling
• Application Generation
• Testing and Turnover

 Spiral Model:-

The spiral model is a risk-based process model. This SDLC model helps the group to adopt elements of one or more process models like waterfall, incremental, etc. The spiral technique is a combination of fast prototyping and concurrency in design and development activities. The following will explain the typical uses of a Spiral Model –

• When there is a budget compellable and risk evaluation is important.
• For intermediate to high-risk projects.
• Long-term project commitment because of probable changes to economic priorities as the requirements change with time.
• Customer is not sure of their requirements which is ordinarily the case.
• Requirements are complicated and need evaluation to get clarity.
• Some changes are expected in the product during the development cycle.

V-Model :-

In this model execution of processes happens in a sequential method in a ‘V-shape’. It is also known as ‘Verification and Validation model’. The V-Model is an Expansion of the waterfall model and is based on the association of a testing phase for each related development stage. That means for every single phase in the development cycle, there is a directly associated testing stage. This is a disciplined model and the next phase starts only after completion of the previous phase.

Incremental Model :-

The incremental model is not a distinct model. It is radically a series of waterfall cycles. The requirements are divided into groups at the initial stage of the project. For each group, the SDLC model is adhered to develop software. The SDLC process repeats with each release adding more functionality till all requirements are met.

use of  Incremental Model:-

• When the requirements are much superior.
• A project has a lengthy development program.
• When Software team are not well skilful or trained.
• When the customer demands an immediate release of the product.
• You can develop precedence requirements first.

Agile Model :-  

The agile model is a model which promotes continuous interaction of development and testing during the SDLC process of any project. The agile model is a combination of iterative and incremental process models with aims on process and customer satisfaction by continuous delivery of working software products. Agile Methods have divided the product into small incremental builds. These builds are issued in iterations. Each iteration lasts from typically one to three weeks. Every iteration involves cross-functional teams working together on various areas like

• Planning
• Requirements Analysis
• Design
• Coding
• Unit Testing and
• Acceptance Testing.

At the end of the iteration, a functional product is displayed to the customer.

Iterative Model :-

In the iterative model, the iterative process starts with the implementation of a small set of software requirements, makes  enhancements in the evolving versions till the complete system is implemented and ready to deploy on the market. In this model development of the life cycle doesn’t start with full requirements, instead, it begins with the implementation of just a part of the software, which will be reviewed to identify further requirements later. This process is repeated till the new version of the software is produced at the end.

Big bang model :- 

The big bang model comprises focusing all types of possible resources in software development and coding with little bit or no planning. This model works best for small projects with the smaller size development team who works together. It is useful in academic software projects as well. It is also an ideal model where requirements are either unknown or a final release date is not provided.

Advantages of the Big Bang Model

• This is very easy to use model
• Little bit or no planning required
• Easy to handle
• Very few resources are needed
• provides flexibility to developers

Disadvantages of the Big Bang Model

• Very High risk & uncertainty.
• Not a good model for difficult and object-oriented projects.
• Poor model for long-term and ongoing projects.
• Can become very expensive if requirements are not properly understood.

Prototype Model :-

The prototype model starts with the gathering of required information to start the development process. In this the developer meets the client, understand the purpose of software and identify the actual requirement. Then a quick design is created, focused on each aspect of the software which will be visible to the user. Then it goes ahead with the development of prototype, customer checks and try to identify if any modification needs to be done. In this step, looping occurs and better versions of prototype are created. It continuously happens being in touch with client to show him if any further requirements needs to be done.  This process remains continue till the user is satisfied. Once the user is satisfied, the prototype is converted into the actual system to deploy in market.

DevOps:-  Let’s understand. In the agile Model, both Development and testing activities were concurrent, unlike the waterfall model. It was lost on practices that didn’t come up to speed with agile practices. Due to lack of collaborations between developers ad the operations team, slow down the development process and releases. Then software companies started realizing the need for better collaboration between teams and faster delivery of software. It gave birth to the DevOps approach. DevOps enabled fast software delivery with minimum problems to fix and faster resolution of problems. The term DevOps is deprived of two words development and operations. DevOps is a practice that allows a single team to manage the whole application development life cycle, i.e. development, testing, deployment, etc. The aim of DevOps is to shorten the development life cycle. DevOps is a software development approach that helps in producing high-quality software with reliability and in less time. DevOps is a software development method that aims at communication, integration, and collaboration between IT professionals to enable continuous deployment of products.

Which SDLC Model is Best

As far I have understood, DevOps is the best model in today’s software ecosystem which provides a better development life cycle with high effectiveness and efficiency in work progress.  But it doesn’t mean rest models are not useful, they are also useful and still getting used by some organizations who feel that model is best in their work. DevOps is a practice of bringing development and operation teams together whereas, Agile refers to the continuous iterative approach, which aims at collaboration, customer feedback, small, and continuous releases. DevOps’ purpose is to manage end-to-end engineering processes. It helps in increasing an organization’s speed to deliver applications and services.  The agile purpose is to manage difficult projects. The agile development process divides the product into smaller pieces and integrates them for final testing. It can be implemented in many ways, including Scrum, XP, etc.

The post Software Development Lifecycle (SDLC) Beginners Guide appeared first on Artificial Intelligence.

In the era of 24-hour news coverage, and in the aftermath of highly publicized catastrophic events including hurricanes, earthquakes and terrorist attacks, insurance policyholders have very little patience for a protracted claims process.

At the risk of alienating customers, especially younger policyholders who grew up in a digital age, the insurance industry must adapt to keep up with the speed of business and increased expectations regarding how companies administer claims.

Consumer expectations aside, there’s also pressure from internal stakeholders who expect up-to-date evaluations of risk and more efficient business practices that drive down costs and create competitive advantages.

So, how can insurance companies redesign their business models, particularly the claims administration process?

Leveraging the wisdom of crowds

With these challenges in mind, innovative insurance companies increasingly see a reason to incorporate alternative data sources as an element of their insurance contracts. Given the prevalence of smartphones and the general public’s willingness to use their social media accounts to share events as they happen, real-time social media posts are often the fastest indications of a breaking event. In fact, governments, news agencies, and businesses commonly rely on social media to keep track of breaking news stories.

The real-time nature of social media dovetails with the need for insurance companies to pick up the pace when processing claims. When analyzed correctly, social media data can inform a parametrics insurance contract, triggering the payment of a predetermined amount when conditions exceed certain metrics, such as the wind speed associated with a hurricane or tremors accompanying an earthquake. In addition to natural disasters, alerts derived from social media could justify payouts of a parametric insurance policy covering a man-made event, such as a terrorist attack.

In short, when a significant incident impacts policyholders, a parametric contract that relies on social media alerts can generate a payment. And there’s an added bonus: After an event, the real-time information from social media becomes historical information that helps underwriters assess future policy risks.

A front-row seat to insured events as they unfold

As the recent hurricane in Puerto Rico or the 2017 terror attack in the Parson Green Underground station in London demonstrate, a spike in volume of real-time social media posts is a leading indicator of breaking news. In the simplest terms, social media posts emanating from Puerto Rico or in the vicinity of the Parson Green station provided compelling evidence of an incident. Over time, as the volume of posts grows, the evidence of a covered event becomes incontrovertible.

Nonetheless, insurance companies don’t need to wait until there’s a vast amount of social media posts to initiate the claims process. With the right tools in place to mine social media, insurance companies can be alerted to an event before the volume of posts surges exponentially.

Whether an insurance company relies on the first post to act or decides to wait until the volume of social media posts mushrooms, the corroborative nature of social media, including the analysis of geolocated posts, offers an up-to-date portrayal of events.

While incorporating alternative data as part of parametric insurance contracts may face organizational resistance, making use of social media data benefits those covered by policies, as well as the insurers themselves — removing the burden of assessing a loss solely off insurance adjusters and shortening the time needed to assess a loss and issue a payment. Customers who are helped quickly are also less likely to complain about service and may support the insurance company publicly, contributing to brand strength.

The rush to leverage social media alerts

Up until recently, the insurance industry has resisted the pressure to jump on the technology bandwagon. However, in the midst of unrelenting changes in consumer expectations, and the proliferation of online insurance upstarts determined to disrupt the industry, many insurance companies are in the process of overhauling their business models and embracing the latest technology.

In particular, the claims process is ripe for change. While the industry’s staid approach to claims used to suffice, today’s policyholders no longer deem it acceptable for insurance companies to take months to evaluate and pay out claims. In order to attract and retain customers, while reducing claims processing costs and creating competitive advantages over less refined competitors, insurance companies must build business models that allow for a faster, more agile response. That means looking beyond the traditional tools and approaches for a nimble solution with the potential to support the accelerated payouts policyholders expect.

Using alerts derived from social media provides claims processors with real-time, actionable alerts, including images and video that offer third-party evidence of an event and the extent of the damage, and consequently, the ability to expedite and automate policy payments. Insurance companies that tap into social media data to speed the claims process may impress policyholders by avoiding typical operational challenges and may help the strength of public brand perception.

The competitive landscape of shifting business models may propel many insurance companies to use social media data as an indispensable linchpin in their revamped claims administration process.

The post Why the insurance industry needs social media data mining appeared first on Artificial Intelligence.

The uninterrupted growth of Big Data in the world is putting forth a problem – that of managing this data. Therefore, organizations all over the world are looking for the “perfect strategy” to get up and running with their share of Big Data.

Implementing Big Data is a challenge for any organization, and for any strategy to succeed, an organization must be well aware of their needs and requirements. Without a clear understanding of these things, the laid roadmap might take you an altogether different destination.

Let’s take a look at five essential steps that you should keep in mind while laying out the roadmap:

1. Convene the Perfect Multidisciplinary Team

 Before even thinking of laying a roadmap, it’s essential to realize that Big Data is not an information technology project, it is a business initiative. So, the team you’re deploying for the same must have people from business and operations departments as well as the IT experts. Ideally, there should be more people from the former as they’re the ones who have a clearer idea of the business requirements.

2. Define the Scope of a Given Problem

While making sense of your data, be extremely clear about what problems you’re aiming to solve. Pick three issues you’d want to be tackled first, and formulate them into questions. Answering those questions will give you an idea of how you want to proceed with your Big Data. These answers will also guide your efforts in narrowing (or expanding) the initial scope of research. Such an iterative approach not only gives clearer insights but also allows you to go back and forth and fix any errors that might have crept in.

3. Assess Internal Data Sources and Silos and Gather External Data

Now that you have your team and questions ready, it’s time to let the cat out of the bag. Any organization has an internal inventory of data sources which will come in handy. While formulating a strategy, a team will want to have references, such as Vendor Contracts, Customer List, Prospect List, Vehicle Inventory, AR/AP/GL, Locations, and other terms that describe the purpose or system from which the data is derived. The list can be expanded for technologists later. More often than not, such information is stored internally in Data Silos.

Other than the internal sources, there are external data sources like Data.gov or your social media channels that generate a lot of data. Data.gov has more than 100,000 datasets, containing millions of rows covering decades. Download only five datasets for each of the three questions that you are trying to answer. For example, the Consumer Price Index (CPI) – Average Price Data from the Department of Labor Statistics includes monthly data on fluctuations in the prices paid by urban consumers for a representative basket of goods and services.

LinkedIn, Twitter, Quora, Facebook, Pinterest, and other social media channels have a more significant impact on the operations of your organization than you realize. Make sure to deploy a couple of team members solely to manage and study the data from social media.

4. Determine Output and Further Measures

Keeping in mind the questions you posed to limit the initial scope, determine what output are you expecting. You also need to understand who you’re pitching the end product to. Will they view it only on a large monitor, or might they see it on smaller screens too? Which data visualizations to use to display the output most concisely? How should the output be validated? There are many important points to address which will make the output understandable to everyone on the team – both tech and non-tech alike.

5. Be Holistic and Agile

Look at your output and analysis from all the dimensions. If your output makes sense, but you aren’t able to explain it to people around you, it’s of no use. Always look out for possible improvements in your final system. One of the four characteristics of Big Data is Veracity, and it talks about the anomalies and noises in your data. What this simply means is that there are chances you might come across errors you hadn’t thought of initially. That is why an iterative, agile approach goes a long way while implementing Big Data systems. In such cases, you need to readjust your budget, team, goals, and ideologies based on the circumstances you’re in.

The post HOW TO BECOME AN EXPERT IN IMPLEMENTING BIG DATA SYSTEMS appeared first on Artificial Intelligence.

The post How AI will impact software development appeared first on Artificial Intelligence.

Microservices have been a focus across the open source world for several years now. Although open source technologies such as Docker, Kubernetes, Prometheus, and Swarm make it easier than ever for organizations to adopt microservice architectures, getting your team on the same page about microservices remains a difficult challenge.

For a profession that stresses the importance of naming things well, we’ve done ourselves a disservice with microservices. The problem is that that there is nothing inherently “micro” about microservices. Some can be small, but size is relative and there’s no standard measurement unit across organizations. A “small” service at one company might be 1 million lines of code, but far fewer at another organization.

Some argue that microservices aren’t a new thing at all, rather a rebranding of service-oriented architecture (SOA), whereas others view microservices as an implementation of SOA, similar to how Scrum is an implementation of Agile. (For more on the ambiguity of microservice definitions, check out this upcoming book Microservices for Startups.)

How do you get your team on the same page about microservices when no precise definition exists? The most important thing when talking about microservices is to ensure that your team is grounded in a common starting point. Ambiguous definitions don’t help. It would be like trying to put Agile into practice without context for what you are trying to achieve or an understanding of precise methodologies like Scrum.

Finding common ground

Knowing the dangers of too eagerly hopping on the microservices bandwagon, a team I worked on tried not to stall on definitions and instead focused on defining the benefits we were trying to achieve with microservices adoption. Following are the three areas we focused on and lessons learned from each piece of our microservices implementation.

1. Ability to ship software faster

Our main application was a large codebase with several small teams of developers trying to build features for different purposes. This meant that every change had to try to satisfy all the different groups. For example, a database change that served only one group had to be reviewed and accepted by other groups that didn’t have as much context. This was tedious and slowed us down.

Having different groups of developers sharing the same codebase also meant that the code continually grew more complex in undeliberate ways. As the codebase grew larger, no one on the team could own it and make sure all the parts were organized and fit together optimally. This made deployment a scary ordeal. A one-line change to our application required the whole codebase to be deployed in order to push out the change. Because deploying our large application was high risk, our quality assurance process grew and, as a result, we deployed less.

With a microservices architecture, we hoped to be able to divide our code up so different teams of developers could fully own parts. This would enable teams to innovate much more quickly without tedious design, review, and deployment processes. We also hoped that having smaller codebases worked on by fewer developers would make our codebases easier to develop, test, and keep organized.

2. Flexibly with technology choices

Our main application was large, built with Ruby on Rails with a custom JavaScript framework and complex build processes. Several parts of our application hit major performance issues that were difficult to fix and brought down the rest of the application. We saw an opportunity to rewrite these parts of our application using a better approach. Our codebase was intertangled, which make rewriting feel extremely big and costly.

At the same time, one of our frontend teams wanted to pull away from our custom JavaScript framework and build product features with a newer framework like React. But mixing React into our existing application and complex frontend build process seemed expensive to configure.

As time went on, our teams grew frustrated with the feeling of being trapped in a codebase that was too big and expensive to fix or replace. By adopting microservices architecture, we hoped that keeping individual services smaller would mean that the cost to replace them with a better implementation would be much easier to manage. We also hoped to be able to pick the right tool for each job rather than being stuck with a one-size-fits-all approach. We’d have the flexibility to use multiple technologies across our different applications as we saw fit. If a team wanted to use something other than Ruby for better performance or switch from our custom JavaScript framework to React, they could do so.

3. Microservices are not a free lunch

In addition to outlining the benefits we hoped to achieve, we also made sure we were being realistic about the costs and challenges associated with building and managing microservices. Developing, hosting, and managing numerous services requires substantial overhead (and orchestrating a substantial number of different open source tools). A single, monolithic codebase running on a few processes can easily translate into a couple dozen processes across a handful of services, requiring load balancers, messaging layers, and clustering for resiliency. Managing all of this requires substantial skill and tooling.

Furthermore, microservices involve distributed systems that introduce a whole host of concerns such as network latency, fault tolerance, transactions, unreliable networks, and asynchronicity.

Setting your own microservices path

Once we defined the benefits and costs of microservices, we could talk about architecture without falling into counterproductive debates about who was doing microservices right or wrong. Instead of trying to find our way using others’ descriptions or examples of microservices, we instead focused on the core problems we were trying to solve.

• How would having more services help us ship software faster in the next six to 12 months?
• Were there strong technical advantages to using a specific tool for a portion of our system?
• Did we foresee wanting to replace one of the systems with a more appropriate one down the line?
• How did we want to structure our teams around services as we hired more people?
• Was the productivity gain from having more services worth the foreseeable costs?

In summary, here are five recommended steps for aligning your team before jumping into microservices:

1. Learn about microservices while agreeing that there is no “right” definition.
2. Define a common set of goals and objectives to avoid counterproductive debates.
3. Discuss and memorialize your anticipated benefits and costs of adopting microservices.
4. Avoid too eagerly hopping on the microservices bandwagon; be open to creative ideas and spirited debate about how best to architect your systems.
5. Stay rooted in the benefits and costs your team identified.

Focus on making sure the team has a concretely defined set of common goals to work off. It’s more valuable to discuss and define what you’d like to achieve with microservices than it is to try and pin down what a microservice actually is.

The post How to align your team around microservices appeared first on Artificial Intelligence.