Tips

Tips

• 5 key software testability characteristics

  How do you design the software components for comprehensive testing? Start with these fundamentals of software testability -- from mocks and stubs to infrastructure-as-code.  Continue Reading

• Get started with a hybrid microservices model

  Enterprises don't always have to choose between a microservices and monolithic architecture -- take a hybrid approach to experience the best of both worlds.  Continue Reading

• What is the difference between Python and Ruby?

  In this article, we explore the genesis of these two programming languages, notable characteristics and differences, and where each language might be headed.  Continue Reading

• 4 trends for Kubernetes cloud-native teams to watch in 2020

  Today's software architectural landscape seems to change like the weather. Stay ahead of the curve with these cloud-related trends, including GitOps and service meshes.  Continue Reading

• A concurrent programming faceoff: Erlang vs. Elixir

  Do you want the strong data integrity of Erlang, or the flexibility of Elixir? We explore the pros and cons of each in this head-to-head language matchup.  Continue Reading

• What is a microkernel architecture, and is it right for you?

  Apps aren't limited to monolith and microservices architecture. Discover the benefits of a microkernel, common plugins and the apps best suited for this type of architecture.  Continue Reading

• Consider these key microservices caching strategies

  Data caching is a key part of ensuring microservices have easy access to the data they need. We review a few key caching strategies.  Continue Reading

• 3 microservices resiliency patterns for better reliability

  The flipside of microservices agility is the resiliency you can lose from service distribution. Here are some microservices resiliency patterns that can keep your services available and reliable.  Continue Reading

• Fundamental patterns for service discovery in microservices

  Service discovery is a huge part of managing a microservices-based application. We examine helpful service discovery patterns developers can use for clean service interaction.  Continue Reading

• 5 big microservices pitfalls to avoid during migration

  Too many development teams make these failure-inducing mistakes during a switch to microservices. Learn where things go wrong, and the best ways to avoid problems.  Continue Reading

• Is microservices adoption right for your organization?

  Assess whether your org will benefit from microservices, and use this expert advice to take the initial steps to make a successful architectural and cultural transition.  Continue Reading

• Rethinking change control in software engineering

  The traditional method of application change control won't fly in a modern, DevOps environment. Here's how we can rethink the process in a time where rapid app development rules.  Continue Reading

• A few fundamental microservices team structure strategies

  A microservices architecture can be quite a culture shock to unprepared enterprises. Here's how you can prepare your team to make microservices part of development processes.  Continue Reading

• The fundamental benefits of programming in Rust

  Why does Rust continue to rise in popularity? We examine the features of this composable, cross-platform language that make it a valid competitor to C-based coding.  Continue Reading

• Pros and cons of monolithic vs. microservices architecture

  Developers interested in shifting to microservices should seriously consider whether a monolithic approach may be the smarter choice. Here are the key factors to consider.  Continue Reading

• Advantages of monolithic architecture that prove it isn't dead

  Don't rush to break up a monolith too quickly without considering what you might lose in the process. We examine why a monolithic architecture is sometimes the smarter choice.  Continue Reading

• Follow these 10 fundamental microservices design principles

  The right design principles enable microservices adopters to build an application from autonomous, cohesive components that can scale seamlessly. Here are 10 to follow.  Continue Reading

• How to improve API documentation with Swagger and OpenAPI

  Discover why developers should take advantage of Swagger tooling and the OpenAPI specification to streamline API design, documentation and management, especially for RESTful APIs.  Continue Reading

• 3 event sourcing patterns that ease app processing

  Examine the pros and cons of three event sourcing patterns that solve certain problems but can introduce new ones in an event-driven architecture.  Continue Reading

• How the .NET Core platform advances cloud-based app deployment

  The capabilities of .NET Core keep developers interested. We break down the reasons why that's the case.  Continue Reading

• How to tackle 5 common event bus pattern problems

  The event bus pattern has quickly become a necessity, but it's not a free ride. Here are five common problems you'll face when you rely on an event bus.  Continue Reading

• How to test microservices for functionality and compliance

  If you're new to microservices testing practices, understand that traditional techniques won't work anymore. We examine how to approach four critical microservices tests.  Continue Reading

• Apigee vs. Mulesoft: An API management platform face-off

  Mulesoft and Apigee are two of the most widely used API management platforms around. This article places them side by side to compare their pros and cons.  Continue Reading

• The benefits of Python are plenty, but it's not for everyone

  Python boasts plenty of features that make it a go-to object-oriented language. But is it always the right choice? We take a look at what you should know about coding with Python.  Continue Reading

• An introduction to combining CQRS and event sourcing

  Combining CQRS and event sourcing is a powerful way to maintain data speed and consistency for web-scale applications. Learn about the pros and cons of pairing these two processes.  Continue Reading

• Scaling microservices takes conceptual skills and good tooling

  Independent scalability is a major benefit of microservices, and simultaneously a complex and challenging thing to implement. Scale microservices with a focus on users' priorities.  Continue Reading

• API gateway comparison: Kong vs. Tyk

  API gateways help organizations smooth out interactions among microservices. This side-by-side rundown of Kong vs. Tyk will help you choose which tool fits your business' needs.  Continue Reading

• The right (and wrong) way to think about code refactoring

  Code refactoring keeps code clean, sharp and efficient -- ideally without changing any of its functionality. Learn how to refactor code without interrupting your deployment pipeline.  Continue Reading

• Scala: Lightweight functional programming for Java

  Scala provides a lightweight code option for Java development, but there could be a steep learning curve. Learn a little about Scala and if it's worth adopting.  Continue Reading

• 3 ways to implement a functional programming architecture

  Functional programming, which came about as a highly theoretical, mathematical way to build software, has a place in APIs and other components of applications.  Continue Reading

• The benefits -- and tradeoffs -- of a mobile SDK

  A mobile SDK can do wonders for mobile app development. But how does it work, and what are the pitfalls to watch out for when you take this approach?  Continue Reading

• Use an API mapping tool to demystify complex API integrations

  Whether a simple diagram or more complex model, an API mapping tool can bring order to loosely coupled application components, speed up debugging and simplify application updates.  Continue Reading

• Compare microservices deployment patterns for best strategy

  To solve pesky deployment woes, match your app to a microservices deployment pattern, like single service instance per host, multiple service instances per host or even serverless.  Continue Reading

• Choose an event-processing architecture for an application

  Sift through the state control methods that exist for event-driven applications and see which architecture type is the best fit.  Continue Reading

• These 6 microservices architecture design patterns solve problems

  Navigate the benefits and drawbacks of standard architecture design patterns that aim to diminish microservices deployment and performance miseries.  Continue Reading

• Elixir functional programming enables concurrency, fault tolerance

  Developers can combine features of Erlang functional programming with a newer language, Elixir, which promises simplicity and fault-tolerant operations for distributed applications.  Continue Reading

• Unravel asynchronous inter-service communication in microservices

  See why microservices need to communicate with each other asynchronously. Then, see how to surmount the challenges of inter-service communication in microservices architecture.  Continue Reading

• Invoke these 3 commandments of microservice applications

  Unlock a microservice app's potential with a three-pillared approach centered on a thorough component directory, absolute service flexibility and reliable backwards compatibility.  Continue Reading

• Match market shifts with a lightweight enterprise architecture

  Lightweight EA can streamline and refine how IT software meets business needs. See which lightweight EA toolkit route fits your team: one focused on an EA model or workflows.  Continue Reading

• Implement and manage an event-driven microservices architecture

  Learn the basics of event-driven architecture as they apply to microservices, with the help of real-world examples and three main architecture patterns.  Continue Reading

• Serverless testing in CI eliminates surprises in production

  Writing in a functional language without intuitive unit test coverage? Don't have control over resources or scaling? Here's how to make serverless testing work anyway.  Continue Reading

• Software reliability engineering practices for distributed apps

  Learn how these four software reliability engineering concepts -- inventories, monitoring, observability and Pareto analysis -- can aid API management and application performance.  Continue Reading

• What semantic monitoring can and can't do for microservices

  Semantic monitoring can identify microservices performance problems, catch bugs in transactions and ensure uptime. But when you test in production, you'd better know what you're doing.  Continue Reading

• Think carefully about API language standards

  API language standards were few and far between in the past, but now cloud has made API standardization more important than ever. Learn what you need to know about these standards.  Continue Reading

• API workflow design patterns for microservices scenarios

  When it comes to workflow systems for microservices, there's no one-size-fits-all approach. Learn about the API workflow pattern options that can set you straight.  Continue Reading

• The essentials of refactoring a monolith to microservices

  Enterprise apps are complex, long-lived and vital to the business. In short, they're excruciatingly difficult to modernize. If you address these prerequisites, it will hurt less.  Continue Reading

• How to design APIs for hybrid cloud architecture

  Hybrid cloud is complex, particularly because it's the application -- not the server -- that manages API flows. Review some strategies for API management in a hybrid scenario.  Continue Reading

• A serverless architecture tutorial for development teams

  Still emerging serverless technology offers some big advantages for development teams. This serverless architecture tutorial can help clarify the basics on where to start.  Continue Reading

• 4 practical methods to increase service resilience

  Resiliency refers to the ability of your architecture to quickly predict, detect and mitigate potential performance failures. Here are four ways to fortify your software.  Continue Reading

• 3 distributed tracing tools perfect for microservices

  Distributed tracing is a critical part of the microservices monitoring processes. Here are three tools that can help provide the view you need to identify strangling bottlenecks.  Continue Reading

• Streamline CI/CD with the Jenkins Blue Ocean tool

  Organizations that run Jenkins may find that plugins complicate their CI/CD pipeline. Here's how the continuous delivery tool Blue Ocean can help keep things on track.  Continue Reading

• Prepare to face these 4 common challenges with microservices

  The benefits of microservices come with a cost. Review four common ways breaking up a monolith can actually complicate routine application development and management tasks.  Continue Reading

• 3 serverless development strategies for stateful applications

  Serverless developers can connect stateless functions to state information in several ways, without introducing debilitating latency to the application design.  Continue Reading

• Use event processing to achieve microservices state management

  What good are stateless microservices for stateful processing? Bring complex event processing into the mix to manage microservices state through scaling and failures. Here's how.  Continue Reading

• How to pick the right application wireframing tool

  Determine the best application wireframing tool for mobile and website projects based on team collaboration, prototype complexity and other real-world factors.  Continue Reading

• Simplify Java-based development with the Kotlin language

  What makes Kotlin popular among Java professionals? Explore the attributes of this functional programming language that's equipped for both traditional Java and Android developers.  Continue Reading

• 8 practical serverless design patterns for enterprise devs

  Serverless app teams can turn to architecture patterns to guide the way to a successful product. Learn the criteria to narrow your options and the key differences between eight patterns.  Continue Reading

• Get realistic about your multi-cloud strategy aspirations

  Multi-cloud is attractive to software teams that want to expand their development toolboxes, but be careful about the complexity it can add to your overall development lifecycle.  Continue Reading

• Explore Clojure programming language and its multithread style

  Discover the fundamentals of the Clojure programming language and its Java-specific uses and tool pairings to see if this multithread programming approach is a fit for your team.  Continue Reading

• 4 tips to tackle common microservices testing problems

  Flaky tests put code quality -- and development team morale -- at risk. Proliferating microservices stress out test environments, so use these techniques to keep everything running.  Continue Reading

• 4 fundamental practices for serverless architecture security

  Are you ready for serverless security? Learn about four critical planning considerations software teams need to focus on if they plan to adopt serverless.  Continue Reading

• Address goals with various enterprise architecture strategies

  Enterprise architects have a range of frameworks at their fingertips, but their role also entails creating consensus and understanding between business and technical stakeholders.  Continue Reading

• How to create a stateful application with service brokers, DTP

  Complex state control issues come with the territory of stateful application design. Learn useful concepts that manipulate state and enable a stateful app to work as envisioned.  Continue Reading

• Discover practical serverless architecture use cases

  While architects and developers were slow to find practical use cases for serverless, numerous enterprise trends should drive the need for this architecture style.  Continue Reading

• ICYMI: 6 tips to master Kubernetes performance and management

  The more skilled the team, the better a Kubernetes implementation can be. Learn how to get the most out of service discovery, infrastructure management, CI and more.  Continue Reading

• What does it mean to be an enterprise API management architect?

  APIs can't be taken lightly, and that means the API architect's job is essential. Learn about essential API architect responsibilities and how organizations can make the most of APIs.  Continue Reading

• The key differences between stateless and stateful microservices

  Not all services are the same. Learn about the fundamental differences between a stateful and a stateless microservice and the appropriate scenarios for each.  Continue Reading

• How to create an efficient container-based architecture

  Containers can introduce as many problems as they solve. In case you missed it, these four articles offer practical advice for consistent and structured container implementations.  Continue Reading

• Let app architecture dictate cloud integration tool selection

  Does your application rely on a homogeneous or heterogeneous stack? Will the architecture evolve? Learn the types of cloud integration and which app and dev team setups they match.  Continue Reading

• How does Ballerina stack up as a cloud-native programming language?

  While WSO2 has high hopes for its microservices-centric and cloud-native programming language, what do developers think of the current version of Ballerina?  Continue Reading

• How API gateways work -- and why you need them

  Learn the essentials of both API gateways and API design. Then, grasp how to use them to modernize monolithic apps and facilitate cloud-native microservices.  Continue Reading

• 5 key management practices for a hybrid cloud architecture

  Workload bottlenecks easily arise between legacy and modern apps in a hybrid cloud. Coordinate integration with these five steps to prep a microservices application for hybrid cloud.  Continue Reading

• Examine 4 hybrid cloud options from bursts to SaaS to CI/CD

  Hybrid cloud can provide an enterprise with a happy medium of cloud and on-premises benefits. Unsure where to begin? Try setting up hybrid web services, software services or development tools, and other practical approaches.  Continue Reading

• Practical ways to automate microservices' CI/CD processes

  Development teams need to make applications extensible and agile. Microservices bring those goals in sight, but an automated CI/CD pipeline is the key to success.  Continue Reading

• Use the Ballerina language to ease into cloud microservices

  With native integration features, Ballerina promises to take care of lower-level technological considerations, while developers focus on building features.  Continue Reading

• Achieve application state management in microservices designs

  Discover the how-tos for managing state in microservices applications, and then evaluate prevalent front-end and back-end state management approaches.  Continue Reading

• 5 ways to manage multiple data sources for high-performance apps

  Applications can pull from and work with data from multiple sources, as long as the app design incorporates these five fundamental data management and mapping techniques.  Continue Reading

• Enable an antilatency cloud event processing architecture

  Event-based applications cannot tolerate unreliable networks or latency. Consider an architecture that puts some event processing local to the source to alleviate cloud traffic.  Continue Reading

• 3 ways to grade integration platform-as-a-service vendors

  The best iPaaS vendors offer a mix of standardization and flexibility, and they can't leave out compliance. Learn how to compare offerings based on these crucial capabilities.  Continue Reading

• How Jenkins X updates this CI/CD tool for the cloud, Kubernetes

  Jenkins wasn't built for the cloud or Kubernetes, but that's not so for Jenkins X. Here's how users can keep their favorite CI/CD tool to build modern cloud apps and work with containers.  Continue Reading

• How integration platform as a service stacks up against PaaS and SaaS

  IT orgs that face a hybrid mix of apps and data sets can turn to iPaaS for integration -- without the overhead of more software to manage. And there's more than one kind of iPaaS.  Continue Reading

• How shared Lambda functions help microservices access control

  Shared Lambda functions can help combat error message issues that arise when developers create custom authentication and authorization for microservices. Here's how they work.  Continue Reading

• 5 common traps lurking in RESTful development

  Unfortunately, many RESTful API developers fall into the same traps during design. Here are five common mistakes that you can avoid with the right planning.  Continue Reading

• These tools help build microservices in Java

  Depending on the mission, developers need to align their tool choices with one of two paths for Java microservices. Here's what you need to know.  Continue Reading

• How Google Cloud Build helps microservices build automation

  Google Cloud Build has the potential to play a valuable and reliable role in CI/CD pipelines for microservices development. Learn how Cloud Build can help.  Continue Reading

• The 2 fundamental approaches to hybrid cloud integration

  Organizations that want to create a hybrid cloud environment need to develop a strategy. Consider these two approaches.  Continue Reading

• The fundamentals of Micronaut and microservices development

  The Micronaut framework offers developers an efficient way to build distributed applications, particularly thanks to quick startup capabilities, a multipurpose CLI and more.  Continue Reading

• 4 development tools that bridge the architect-developer gap

  There can be a frustrating divide between the role of software developer and architect in any organization. There are ways to bridge that chasm, and one of these four tools just might help.  Continue Reading

• How to prepare your own container development kit

  A container development kit helps confederate containerized application development and transition developed components between clusters. Here's how to create your own.  Continue Reading

• How to build microservices with Spring Boot and Spring Cloud

  Spring Boot and Cloud can certainly help developers tackle microservices, but it's not for everybody and, unfortunately, there are a few important limitations to consider.  Continue Reading

• 3 serverless platform approaches to consider

  There are several ways to approach serverless, and each has pros and cons. Learn where cloud, open source and the more traditional platforms fit into the serverless conversation.  Continue Reading

• 3 ways to minimize critical container vulnerabilities

  Containers are complex, and it takes some work to keep your container components and images safe from attack. Here are three critical container development security practices.  Continue Reading

• Combining serverless and microservices has its benefits

  Uncover the advantages that result from coupling serverless with microservices, and see how cloud providers prepare for customers to use these technologies together.  Continue Reading

• Pair AWS with microservices deployment to meet CI/CD goals

  When combined with microservices, these AWS offerings can provide an easier way to adopt a fully Agile development methodology.  Continue Reading

• Practical ways to implement function as a service

  Developers are ready to work with function as a service but still need some guidance. Learn about FaaS implementation models and which FaaS platform offering is for you.  Continue Reading

• The top ways microservices impact EDI processes

  B2B integration has changed, and traditional EDI transaction methods may not meet modern needs. Here is how microservices can help organizations simplify today's complex B2B endpoints.  Continue Reading

• To address microservices issues, turn to OOP principles

  Developers may graduate to microservices from object-oriented programming, but the fundamental principles of OOP still apply, even if the techniques have changed.  Continue Reading

• 5 tips to help effectively manage container components

  The layered approach is commonly used with Docker containers, but it's important to keep container components under control. Here are five crucial tips.  Continue Reading

• How to use microservices to manage serverless APIs

  Monolithic applications may be a little bit heavy for development of serverless APIs, but microservices can make all the difference. Here's how to make it work.  Continue Reading

• Open source tools to consider for your RESTful APIs

  Software teams don't have to break the bank when they shop for RESTful API management tools. The right combination of tools that use open source code can help manage the whole lifecycle at low cost.  Continue Reading