Tips
Tips
Software development lifecycle
-
The 7 stages of the SDLC explained
The development process can be broken into seven distinct phases that transform high-level plans into production-ready software. Learn how to approach each phase of the SDLC. Continue Reading
-
Learn the phases of feature-driven development
Learn how development teams can use the five phases of feature-driven development to put Agile principles into practice by structuring projects around app functionality. Continue Reading
-
Applying Kanban principles to software development
Kanban was conceptualized in manufacturing and later adopted by software development teams, alongside other methodologies, such as Lean and Scrum. Learn to apply Kanban principles. Continue Reading
-
Understanding code linting techniques and tools
Linting is an important preliminary step in the debugging process. Learn how fixing simple errors early on makes code easier to work with and improves coding practices. Continue Reading
-
Create an open source security policy for your organization
Using open source software raises concerns about security and intellectual property. Here's how to make sound decisions and avoid situations you'll regret. Continue Reading
-
6 green coding best practices and how to get started
Software developers can support sustainability efforts via a range of green coding tactics. These best practices range from shrinking artifacts to maximizing efficiency. Continue Reading
-
Best practices for automated end-to-end testing
Advanced end-to-end testing can save a company time and money, but it isn't easy to implement. Let's look at some of the important elements of test design. Continue Reading
-
How to compare acceptance criteria vs. definition of done
Acceptance criteria and the definition of done both measure quality in product development, but the ways teams calculate and achieve these features vary dramatically. Continue Reading
-
Explore the benefits of Docker for testers, QA teams
From simplified test setup to enhanced isolation, Docker containers offer a range of advantages to QA engineers. Containers also encourage earlier, and more frequent, testing. Continue Reading
-
7 essential GitHub features for dev, project management
When teams use GitHub, they want features that simplify project management and enable more control. Here are seven features to tinker with during application development. Continue Reading
-
CircleCI vs. GitHub Actions: CI/CD platform comparison
Learn the differing features, commands and perks that make CircleCI and GitHub Actions distinct CI/CD platforms. Then, decide which offering meets your team's needs. Continue Reading
-
6 key phases of the software testing lifecycle
For QA teams, a successful software testing process starts long before the actual test occurs. Continue Reading
-
Identify and fix broken builds with CI/CD pipelines
Experiencing broken builds in your CI/CD pipeline? These best practices related to credentials, flaky tests and alerts can boost productivity and confidence. Continue Reading
-
Implement reliability testing methods, tools for better dev
Reliability testing can play an integral role in software development. Here are some methods and tools to incorporate into your app development lifecycle. Continue Reading
-
Continuous integration principles and standards to implement
Development and DevOps teams, abide by these best practices and standards to make your IT organization's continuous integration processes as effective as they can possibly be. Continue Reading
-
How to build a CI/CD pipeline with Azure and GitHub
Some organizations need to build and deploy apps to specific cloud platforms. This walkthrough shows you step by step how to create a CI/CD pipeline using GitHub and Azure DevOps. Continue Reading
-
How to address 5 common CI/CD implementation challenges
CI/CD removes the manual steps involved when you create and install application code. Address these CI/CD challenges and ease the flow of your software pipeline. Continue Reading
-
6 ways to harness test automation in a CI/CD pipeline
Effective automated checks in CI/CD help minimize and mitigate bugs and keep software builds and deployments running on time. Try these practical tips in your pipeline. Continue Reading
-
9 CI/CD best practices for DevOps teams
Building and maintaining a CI/CD pipeline requires more than just chains of automation. Adopt these CI/CD approaches to maximize your development and deployment efforts. Continue Reading
-
The pros and cons of CI/CD pipelines
Many enterprises begin their DevOps journey with a continuous development and delivery pipeline. Before you get started, understand some fundamental CI/CD pros and cons. Continue Reading
-
How to write a good user story for cleaner code
A good user story isn't always easy to write. Answer key questions in easily understandable language to get development teams on the same page. Continue Reading
-
Clear up CI vs. CD confusion for DevOps practices
How do CI and CD differ? And how should development shops distinguish between the two? Learn more about the processes and how they've valuable in a DevOps environment. Continue Reading
-
9 techniques for fixing bugs in production
Some companies defend against bugs with a strong offense of rapid iterations and feature flags. Others find the best defense is thorough test coverage. Here's what works and why. Continue Reading
-
GitKraken vs. Sourcetree: Pick a Git GUI that fits dev needs
Git GUIs give developers a visual means to manipulate source code repositories. Learn why GitKraken and Sourcetree are popular options among developers, and where each stands out. Continue Reading
-
How to prevent accidental complexity in software development
Software products contain both essential and accidental complexity. To fight accidental complexity, avoid overambitious designs, coding flaws and other common problem areas. Continue Reading
-
Top 5 benefits of Jenkins for CI/CD pipelines
Many software teams continue to use open source Jenkins for CI/CD, despite other platforms on the market. Here's how Jenkins fits what teams look for in CI/CD tools. Continue Reading
-
Top software documentation tools and how to use them
The best software documentation helps frame development projects and improve existing offerings. Learn the ins and outs of popular software documentation types and tools. Continue Reading
-
4 common software maintenance models and when to use them
Should you use a quick-fix or closed-loop maintenance model for the software project on your development team's plate? What about iterative? Learn the benefits, use cases and limits of four common models. Continue Reading
-
Reduce these forms of AI bias from devs and testers
Watch out for cognitive biases in every development and testing decision -- especially AI biases that affect software users. Here are the ways to address common issues. Continue Reading
-
Pick user-centric software performance testing metrics
Unlike other types of tests, performance tests gauge how well an application works -- not whether it fails. Testers must pay close attention to these metrics to keep end users happy. Continue Reading
-
Use intrusive testing to push software to, and past, its limits
Grab your sledgehammer and get to work with destructive software testing. Here's how to use these intrusive methods to identify points of failure before software reaches users. Continue Reading
-
10 tips for effective change management in Agile
Agile development encourages product owners to address customer needs through change. Follow these 10 tips for change requests and management practices that keep projects on track. Continue Reading
-
How to tame ever-changing requirements in software development
When one sprint ends, another begins -- but not before you receive a heaping new pile of requirements. Here's how to deal with requirements changes efficiently, every time, any time. Continue Reading
-
Working with Git branches and repositories
With a grasp of just a few basic concepts and commands, developers can use Git's branching capability for feature development and experimentation, testing before release and more. Continue Reading
-
How to achieve speedy application response times
Development and operations teams both have a responsibility to ensure fast application response times. Follow this advice to measure and reduce delay. Continue Reading
-
ALM tools face-off pits SpiraTeam vs. Jira
Development teams must adopt an ALM tool that supports its procedures and objectives. Atlassian and Inflectra cater to different size dev teams. Which tool fits your needs? Continue Reading
-
Discern these open source license terms to avoid legal snags
Fluent in Ruby but at a loss in legalese? Open source licenses obligate developers to observe specific conditions, so you must know these terms. Let's break them down in plain English. Continue Reading
-
Define a continuous improvement process with EA models, practices
Continuous improvement isn't just about centers of excellence or feedback loops. Ultimately, it must bring the vast enterprise architecture into rapid-fire code changes, and vice versa. Continue Reading
-
5 common open source software licenses you need to know
Everyone likes getting credit, but not everyone remembers to give it. Learn what conditions open source licenses impose, such as copyright notices and redistribution rules. Continue Reading
-
How GitHub and Bitbucket augment key Git features
Learn how GitHub and Bitbucket enhance the Git version control system, enabling management and security on top of Git's native abilities to clarify workflows and protect data. Continue Reading
-
Enlist Jira for testing with these test management add-ons
With the right add-ons, Jira users can turn the tracking product into a potent test management platform. Gauge your organization's Agile maturity, and then consider these options. Continue Reading
-
Common software compatibility issues and how to fix them
Developers tend to look forward, to the next iteration or the newest software. But, when releasing a feature, don't leave behind end users with older systems and edge case setups. Continue Reading
-
How low-code governance helps IT protect data, limit sprawl
Low-code app developers must adhere to policies that govern data and resource usage. Lacking governance puts budgets, security and compliance at risk. Continue Reading
-
Select between distributed version control systems and tools
Before you branch out with a new version control tool, assess the pros and cons of these different options, and make sure to ask for developers' opinions. Continue Reading
-
How to deprecate software features without bothering users
There's more to software deprecation than it seems. Organizations must consider the method of deprecation, how to inform users and what alternatives they should offer. Continue Reading
-
Compare trunk-based development to feature-based approaches
The repo-centric trunk-based development model can be a good fit for teams adept enough to maintain a codebase. But it means taking the road less traveled. Continue Reading
-
Concourse vs. Drone: Pick a CI/CD tool that fits your team
For CI/CD, a software team should weigh how well a tool fits into its existing practices. Drone and Concourse each highlight ease of use and pipeline features. Continue Reading
-
How to document software requirements without hating your job
Software requirements specifications explain, in painstaking detail, what is expected of a project. So, why develop without one? It's not worth the risk. Read why an SRS is vital. Continue Reading
-
How to write and structure worthwhile SRS documentation
Software projects contain many moving parts, and a miscommunication can derail them easily. Keep everyone on the same page with clear and exhaustive requirements specifications. Continue Reading
-
Ansible vs. Puppet: Declarative DevOps tools square off
Vendors in the declarative DevOps space cater to the increasing emphasis on software quality in the release cycle. See how Puppet and Ansible stack up in this face-off. Continue Reading
-
Learn the basics before you work with Git
Git can scale with complex environments, but more conflicts can arise. Get the Git basics down before your developers use forks or branches for projects. Continue Reading
-
Which APM tool works for devs, CIOs? New Relic vs. Stackify
Stackify Retrace and New Relic tools typify a divide between developers and CIOs on application monitoring. The products share many capabilities, but those features aren't equally granular or accessible. Continue Reading
-
Construct a better build-deploy pipeline with these 6 measures
Developers can launch code to production faster than ever, and still do it safely, with careful attention to the build-deploy pipeline, tests and monitoring metrics. Continue Reading
-
The developer's crash course to the application network
Developers, we get it; you don't want to deal with the network. But hear us out, as a basic understanding of subnets, VPNs and IP addresses boost app stability and performance. Continue Reading
-
Prevent AI bias in predictive applications before it starts
While AI offers predictive insights, developers must train AI models to ensure accurate results. These five types of input, in particular, can cause poor output from the finished app. Continue Reading
-
What the CI process can and can't do for software delivery
Continuous integration, software delivery and deployment are distinct software lifecycle stages, but they are far more complementary than competitive in modern dev methodologies. Continue Reading
-
Jenkins basics: The DevOps and build platform for dev teams
Software expert Walker Rowe discusses how Jenkins goes beyond a DevOps tool. Get a better understanding of how and why your enterprise should install Jenkins. Continue Reading
-
Agile application lifecycle management is not an oxymoron
Learn how Agile application lifecycle management supports the development process for better software and business needs. Continue Reading
-
Agile project management using the Cynefin framework
Learn how the Cynefin framework facilitates problem solving, Agile project management and teamwork. Continue Reading
-
Agile ALM tools: How they differ from traditional lifecycle management tools
Software consultant Nari Kannan describes the differences between agile application lifecycle management (ALM) tools and traditional lifecycle management software. Agile ALM tools are more tightly integrated, easier to use, supportive to distributed... Continue Reading
-
Eight steps for a successful software release
Have you done everything to prepare for a successful software release? Software project manager Kay Diller describes eight things you can do to ensure your deployment will go smoothly. From creating your team to being prepared with a back-out plan, ... Continue Reading
-
What is a test case? What is a requirement?
After exploring the definition of a test case by surveying test experts, authors and students, consultant Robin Goldsmith learns that interpretations remain ambiguous and varied. Similarly, the level of detail thought to be needed to define ... Continue Reading
-
Defining report requirements with use cases
This tip offers a new and interesting way to go about defining and reporting requirements for use cases. There are a number of details that need to be attended to in defining requirements such as taking a look at users and then constructing use ... Continue Reading
-
How requirements use cases facilitate the SDLC
Learn software use case processes and techniques that result in better application requirements in this tip. Takeaways include use case diagrams and user acceptance test case examples. Continue Reading
-
Defining requirements during software project feasibility analysis
There are at least two key points in a software project when requirements should be defined. One point people often miss is during feasibility analysis, and failure to define requirements at this stage can doom a project. Continue Reading
-
How to document system, software requirements
There are various formats you can use to document system and software requirements. However, no single one is sufficient to represent all requirements. You need to follow an integrated approach. Continue Reading
-
Software requirements: Using models to understand users' needs
Successful software projects involve users early and often to explore and reach closure on requirements. Using analysis models you can depict user needs with a combination of diagrams and structure text such as tables or templated text. Continue Reading