Tips

Tips

• The differences between SVN and Git that matter

  Not sure how to pick between Git and SVN for your versioning needs? We break down the key differences between these tools, including their most potent benefits and drawbacks.  Continue Reading

• BPM vs. BPA: The differences in strategy and tooling

  The differences between BPM and BPA come down to process complexity, an organization's proficiency with software code and how quickly the business must see ROI.  Continue Reading

• Webhooks explained simply, and how they differ from an API

  Webhooks and APIs seem to both accomplish the same goal. So what's the difference? We review what a webhook does, how it differs from an API, and where it is the right design choice.  Continue Reading

• The 4 rules of a microservices defense-in-depth strategy

  Learn the four must-follow rules when introducing defense-in-depth to a distributed microservices architecture, especially when services traverse numerous networks and apps.  Continue Reading

• Two simple ways to create custom APIs in Azure

  Learn how to create custom APIs in Azure through both Azure Portal and Visual Studio Code, and review some post-deployment best practices that add value and security to those APIs.  Continue Reading

• The CAP theorem, and how it applies to microservices

  Learn the fundamentals of the CAP theorem, how it comes into play with microservices and what it means for your distributed architecture design choices.  Continue Reading

• Objective-C vs. Swift: The war for iOS development supremacy

  While Objective-C still holds the crown, Swift is quickly mobilizing to rule iOS development. Let's examine and compare the most compelling features of each language.  Continue Reading

• Using the saga design pattern for microservices transactions

  We explore how the saga design pattern can support complex, long-term business processes and provide reliable rollback mechanisms for multistep transaction failures.  Continue Reading

• How to master microservices data architecture design

  Microservices have data management needs unlike any other application architecture today. You'll need the right set of knowledge, mechanisms and design principles to succeed.  Continue Reading

• A head-to-head GraphQL vs. REST performance faceoff

  Both GraphQL and REST aim to simplify API development processes, but which one is right for your project? Find out by examining this API design style faceoff.  Continue Reading

• Navigating the evolving BPA tools market

  The BPA market tool landscape is still maturing, but organizations should prepare themselves to adopt it. Review the basics of BPA and learn how to start building your automation strategy.  Continue Reading

• The vicious cycle of circular dependencies in microservices

  Modular design is impossible so long as circular dependencies lurk in your architecture. So how can you break problematic coupling between otherwise-independent components?  Continue Reading

• 4 mobile app security threats all developers must face

  Mobile apps carry their own set of code-based vulnerabilities and entry points, meaning developers need to step up their secure development, coding and deployment practices.  Continue Reading

• 9 tried-and-true open source frameworks for development

  No matter which type of application you are developing or what your priorities are, there is likely an open source framework that caters to your needs.  Continue Reading

• Microservices logging best practices every team should know

  Creating a log system for distributed microservices is a task much easier said than done. Joydip Kanjilal offers a few best practices to shore up microservices logging processes.  Continue Reading

• Django vs. Node.js: Pick the right web development framework

  Understanding the differences between Django and Node.js comes down to understanding their data capabilities and the programming languages that make up each one's history.  Continue Reading

• Understanding the modular monolith and its ideal use cases

  While it isn't always the right fit, a modular monolith can often provide a happy medium between the simplicity of a traditional monolith and the complexity of microservices.  Continue Reading

• The non-tech skills of software development project managers

  Teams are key to the success of any enterprise software project, but development teams don't run themselves. Managers need the right skills to keep their employees on track.  Continue Reading

• How to start managing software development teams like a pro

  Team performance is vital to a software project's success. Avoid these common management challenges and learn about the key metrics that help monitor your team's effectiveness.  Continue Reading

• A basic overview of micro front ends

  Microservices enable independent app-dev teams, asynchronous app updates and precise troubleshooting. If these benefits sound good for your UI, consider a micro front end.  Continue Reading

• Apache, Spring and Mule: Explore 3 top integration frameworks

  A good integration framework should underpin every application strategy. Apache Camel, Spring Integration and Mule ESB can simplify integration at scale. We deconstruct them here.  Continue Reading

• The basics of software coupling metrics and concepts

  To move toward a distributed, modular architecture, development teams need to carefully investigate software coupling concepts and learn how to measure dependency complexity.  Continue Reading

• A lesson on how to test microservices locally

  Microservices are small pieces of a big picture, so they're difficult to test in isolation. Use these tips to run unit and integration tests locally on microservices.  Continue Reading

• MVC vs. MVVM: 2 architecture patterns for modularity

  Both the MVC and MVVM design patterns separate front-end and back-end application components, but each one has unique methods of interface manipulation and abstraction.  Continue Reading

• Learn the benefits of microservices orchestration

  Orchestration plays a vital role in a microservices architecture, especially when it comes to communication, workload management and architecture readability.  Continue Reading

• A breakdown of object-oriented programming concepts

  Object-oriented programming has set a dominant example of proper data management for complex software and web apps. Learn about the basics of this approach and its role in Java.  Continue Reading

• A primer on the clean architecture pattern and its principles

  Stability is a crucial aspect of application architecture. Learn how clean architecture can straighten out your dependencies and make an app that is built to last.  Continue Reading

• Orchestration vs. choreography in microservices architecture

  Orchestration and choreography are related, but they each have their own role to play. Get to know the basics of these service call approaches, including the use cases for each.  Continue Reading

• Styles, protocols and methods of microservices communication

  As application architectures grow in complexity, messaging must become a priority. Review the two types of microservices communication and the primary protocols involved.  Continue Reading

• A developer guide to software localization

  Software has become as multilingual and multicultural as the world itself. Localizing your code can keep your company from a potentially disastrous cultural blunder.  Continue Reading

• Explore 10 popular open source development tools

  Whether you're writing, managing, building or deploying source code, there is an open source development tool to help do the job. Check out these quick tool intros to get you started.  Continue Reading

• 10 of the best programming languages to learn in 2020

  Different jobs call for different programming languages, and the wrong choice could cause your project to fail. Add these tools to your must-learn list so you are prepared for any assignment.  Continue Reading

• Decomposing a monolithic database for microservices

  When breaking up a monolith, it's critical to decompose your database alongside your new distributed services. We explore how to do this and avoid creating a distributed monolith.  Continue Reading

• Navigate service discovery in a microservices architecture

  Microservices move rapidly, making streamlined service discovery a must. Learn more about the specific types of discovery approaches and how to determine a strategy.  Continue Reading

• Craft an application integration strategy and pick the best tool

  Application integration is easier said than done. Learn how to navigate this challenging process -- particularly, if you're integrating legacy applications with new applications.  Continue Reading

• Synchronous vs. asynchronous communications: The differences

  While asynchronous communications does not wait around for a reply, synchronous execution requires parties or components to work simultaneously in real time.  Continue Reading

• A comparison of 6 top programming languages

  Choosing the right programming language can be tough. We place six popular languages head to head: Python vs. Ruby, Kotlin vs. Swift and Erlang vs. Elixir.  Continue Reading

• Why COBOL modernization matters, and how devs can react

  With COBOL expertise in high demand and low supply, it may be time for devs to think about how much they really know about this language. We explore why COBOL skills still matter.  Continue Reading

• What is the strangler pattern and how does it work?

  The strangler pattern allows software teams to retire legacy systems incrementally and avoid the pitfalls of major rewrites. We examine this pattern and detail the steps involved.  Continue Reading

• 4 best practices for creating architecture decision records

  An ADR is only as good as the record quality. Follow these best practices to establish a dependable ADR creation and maintenance process.  Continue Reading

• 5 major reasons to adopt an API management platform

  Why adopt an API management platform? Examine when it makes sense to adopt a platform, and five major ways they can actually assist your DevOps teams.  Continue Reading

• An enterprise architect's guide to the data modeling process

  As volumes of both business and application data grow, organizations need a strict, three-phase data modeling process that keeps that data contained and manageable.  Continue Reading

• 5 application performance metrics all dev teams should track

  You've deployed your application, now what? To keep your application performing well, you need to track various metrics. Take a look at these five critical KPIs.  Continue Reading

• How to start using a BDD framework

  Why bother with behavior-driven development? Learn how this Agile-focused development framework can help bolster application quality, and explore tooling that can help.  Continue Reading

• Get started with API versioning and URIs

  Applications change, and the APIs they depend on need to be updated and upgraded accordingly. Developers who know the value of versioning and the basics of numbering improve APIs.  Continue Reading

• Refactor vs. rewrite: Deciding what to do with problem software

  At some point, all developers must decide whether to refactor code or rewrite it. Base this choice on factors such as architectural soundness, time, money and goals.  Continue Reading

• 3 lessons microservices developers can learn from SOA

  Microservices developers can learn from past SOA mistakes to build more resilient and high-performance applications today. Take a look at three major lessons for microservices projects.  Continue Reading

• A review of top software architecture visualization tools

  Developers need access to up-to-date software diagrams and documentation. Here are seven tools, from Visio to Mermaid, that provide visual models of code and design patterns.  Continue Reading

• How to fuse domain-driven design and microservices

  Domain-driven design helps organizations create business capabilities with the architecture that microservices need. Here's how to merge DDD into your development process.  Continue Reading

• Kotlin vs. Swift: An open source programming language face-off

  Take a look into what Kotlin and Swift have to offer in terms of cross-platform capabilities, library support and ease of use. Also, review their major strengths and limitations.  Continue Reading

• The 5 essential elements of an RPA strategy

  RPA's benefits can be wiped out by an improper implementation. Give your business a sound RPA strategy and roadmap before you rush in.  Continue Reading

• Getting to know the API proxy

  Explore the capabilities and practical uses for an API proxy, as well as examine the relationship between an API proxy and an API gateway.  Continue Reading

• 4 microservices antipatterns that ruin migration

  A migration to microservices can quickly lead to a chaotic heap of overly-coupled modules and fragile code. Here are the most critical microservices antipatterns to avoid.  Continue Reading

• Use tokens for microservices authentication and authorization

  Independent and interoperable microservices require a permissions rethink, or you'll drive users crazy. Examine how tokens come into play for authentication and authorization.  Continue Reading

• The 7 crucial RPA developer skills

  As enterprises move in on RPA, they need developers who can juggle both the business and technical sides of automation. Here are seven essential RPA developer skills.  Continue Reading

• How to plan and execute a migration to microservices

  Ready for a migration to microservices? Here are the steps your development team can take to gradually transition your existing monolithic applications.  Continue Reading

• The 3 tenets of microservice messaging patterns

  In a microservices architecture, there's no question that it's tricky to ensure effective service communication. Review these three tenets of microservice messaging patterns.  Continue Reading

• 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

• 4 fundamental microservices security best practices

  Despite the benefits, microservices will introduce profound security issues. We review the biggest microservices security challenges and four strategies used to combat them.  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

• Node.js vs. .NET Core: 3 key considerations

  Both open source development runtimes offer advantages for web and mobile builds, so developers should choose based on performance, containers and scaling as well as peer support.  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

• 5 ways to get complex event processing right

  How should software teams make the best use of complex event processing, and how can they implement it successfully? This article looks at five fundamental truths about CEP.  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