Tips

Tips

• Will .NET 6 features bridge the gap between .NET frameworks?

  Microsoft's original .NET Framework has come a long way, but will the new iterations of this framework be enough to convince developers to leave it behind?  Continue Reading

• How a microservices chassis regulates cross-cutting concerns

  Those who've implemented a microservices architecture know that it presents a formidable collection of cross-cutting concerns to manage. Luckily, a microservices chassis might help.  Continue Reading

• Programming in Ruby: A critical look at the pros and cons

  While Ruby showcases an impressive spread of beneficial features, there are still specific shortcomings that may explain why its adoption numbers have been conspicuously erratic.  Continue Reading

• The distributed monolith: What it is and how to escape it

  Do you suspect that your attempt at microservices left you with distributed monolith application design? There are some telltale signs -- and, thankfully, a few ways to escape it.  Continue Reading

• PHP 8 features that prove it's for more than just web

  Looking to keep up with the demand for increasingly sophisticated development capabilities, PHP 8 brings interesting new integrations that transcend the realm of web development.  Continue Reading

• 8 fundamental microservices security best practices

  Despite the benefits, microservices will introduce profound security issues. We review the biggest microservices security challenges and eight strategies used to combat them.  Continue Reading

• The architectural impact of RPC in distributed systems

  It has become increasingly important for software architects to understand the mechanics behind remote procedure call (RPC), particularly its role in distributed architectures.  Continue Reading

• Service mesh vs. API gateway: Where, why and how to use them

  While they're both central to inter-application communication processes, it's important to understand the fundamental differences between a service mesh and an API gateway.  Continue Reading

• Should you adopt an API-first approach to development?

  While the code-first approach certainly works, its appeal is fading as architectures become increasingly complex webs of software. Learn why the API-first approach is catching on.  Continue Reading

• The functional programming paradigm at enterprise scale

  Many enterprise-level architects rely on an object-oriented approach, but there are good reasons and practical ways to introduce functional programming within large-scale systems.  Continue Reading

• .NET vs. Node.js: What they are, and which to choose

  The choice between using .NET and Node.js for application development shouldn't be a difficult one but requires a solid understanding of each approach's pros and cons.  Continue Reading

• Synchronous vs. asynchronous communications: The differences

  Synchronous execution requires parties or components to work simultaneously in real time, while asynchronous communications don't need anyone to wait around for a reply.  Continue Reading

• The 4 Golden Signals, and how to put them into practice

  There's nothing easy about monitoring distributed systems, but the right metrics can help. Here's how to put the Golden Signals of software reliability to work.  Continue Reading

• Microservices vs. SOA: Choose the right app architecture

  This primer explains the ins and outs of a microservices vs. SOA architecture: when and where to use either one, and how both are evolving, thanks to containers.  Continue Reading

• How microservices and containers work, apart and together

  Microservices and containers are two methods that enable companies to more efficiently create and deliver applications. Here's how they work -- and when they're best used together.  Continue Reading

• Microservices vs. APIs: How they differ and work together

  Enterprises still rely on monolithic systems, but apps increasingly require speed, scale and flexibility. Here's how microservices and APIs achieve that, separately and together.  Continue Reading

• How pub/sub messaging works, and why it matters today

  While pub/sub has been a standard messaging approach for decades, it's arguably more important than ever for developers to understand what it is, how it works and why it matters.  Continue Reading

• How to handle typical event-driven architecture failures

  Adding events to an architecture can pose plenty of problems. Review some common event-driven architecture failures development teams face, and some strategic fixes for them.  Continue Reading

• The 6 non-negotiable REST architecture constraints

  While REST-centric design isn't necessarily hard, there are some non-negotiable rules when it comes to resource provisioning. Here are six all architects should know.  Continue Reading

• Static vs. dynamic typing: The details and differences

  What are the key differences between static typing and dynamic typing, and what role do their differences play in the decision to use one programming language over another?  Continue Reading

• 5 proven patterns for resilient software architecture design

  Maintaining a resilient software architecture is a constant battle. Luckily, there are a few design methods that can help teams instill the reliability they desperately need.  Continue Reading

• Is integration platform as a service right for you?

  Is iPaaS a helpful platform for your enterprise software integration needs or just an unnecessary tool that adds complexity to the environment?  Continue Reading

• Event-driven vs. message-driven: It comes down to complexity

  While the goal doesn't change, how do message-driven and event-driven design approaches really differ? More importantly, how do you choose the right approach?  Continue Reading

• IPaaS vs. API management: Why the enterprise needs both

  Enterprise iPaaS and API management integrate applications and data, but it's not a choice of one or the other. Here's why you probably need both, and why planning is necessary.  Continue Reading

• Review these top enterprise iPaaS benefits and challenges

  Have you considered using an iPaaS to integrate your various apps? Understand where iPaaS works, and runs into challenges, to help prepare for a successful iPaaS implementation.  Continue Reading

• 9 iPaaS use cases for the enterprise

  IPaaS connects enterprise applications and data, which encompasses on-premises systems to the cloud and IoT. Review these iPaaS examples to understand how it all works.  Continue Reading

• The reasons to use (or not use) sidecars in Kubernetes

  Sidecar containers provide a great relief to developers who need to manage large clusters of containerized applications at scale. But is it always the right approach?  Continue Reading

• Do the disadvantages of service-oriented architecture matter?

  While it doesn't carry the shiny appeal of microservices, there's no reason to believe that SOA is totally down for the count. In fact, sometimes it's an essential approach.  Continue Reading

• A quick rundown of multi-runtime microservices architecture

  Learn the basics about a multi-runtime architecture, and the two-component approach it takes to provide a standard for abstracted microservice-messaging processes.  Continue Reading

• Feature toggles: A simple fix for complex release cycles

  While development teams should always strive to improve app functionality, unchecked collections of feature releases can quickly cause trouble. Feature toggles may be the answer.  Continue Reading

• Why microservices and IoT apps are perfect together

  The development of IoT apps certainly presents its fair share of challenges, but the benefits that microservices bring might be an antidote to those struggles.  Continue Reading

• Using a business rules engine to streamline decision-making

  Get to know some of the details behind a business rules engine, particularly the automated approach it takes to handling critical, rules-based decisions.  Continue Reading

• Is life as a freelance software developer for you?

  Succeeding as a freelance developer requires much more than waiting for clients to contact you. Explore how to boost your skill set and land freelance gigs.  Continue Reading

• Micro apps: A simple way to add sophisticated features

  When building a new web or mobile app seems like overkill, micro apps might be the most practical way for developers to add niche features and functionality.  Continue Reading

• Diagrams.net vs. Lucidchart: A few things to consider

  While UML diagramming is a relatively universal approach, not all visualization tools are made for the same crowd. Diagrams.net and Lucidchart offer a good example of this.  Continue Reading

• The difference between front-end and back-end developers

  While front-end and back-end application development are two parts of a greater whole, the specifics of each career present some stark differences between them.  Continue Reading

• Can a loosely coupled architecture reduce technical debt?

  While there are a lot of factors that impact technical debt, the level of coupling found in the underlying software architecture is often a primary culprit.  Continue Reading

• 3 predictable application architect interview questions

  Software architecture roles are awfully industry specific, but there are still baseline skills employers want to see. These are some of the questions they ask to find those skills.  Continue Reading

• A quick rundown of 3 layered architecture design styles

  N-layer, hexagonal and onion are all layered architecture styles, but each one features its own unique spin on distributed design and modular development.  Continue Reading

• An application architect's chief roles and responsibilities

  Today's application architect isn't just a high-caliber developer, but an experienced leader with both the technical and business chops to propel an organization's software strategy.  Continue Reading

• Get to know 4 microservices versioning techniques

  Are you struggling to apply updates consistently across distributed services? Here are four microservices versioning techniques that can help.  Continue Reading

• Event-driven architecture pros and cons: Is EDA worth it?

  Event-driven architecture (EDA) is a double-edged sword of service flexibility and management complexity. Let's take a quick look at the ups and downs of EDA.  Continue Reading

• App interface design principles all developers should know

  The first step in choosing the right app interface design is to understand the options available to developers. Dive deeper into these popular design concepts and approaches.  Continue Reading

• An overview of headless architecture design

  Decoupling the back-end components of an application is certainly valuable, but what about the front end? This is where headless architecture comes into play.  Continue Reading

• NetBeans vs. Eclipse: 5 key comparison points for these IDEs

  When implementing IDEs into an application architecture, Eclipse and NetBeans are often top contenders. But is one of these IDEs really better than the other?  Continue Reading

• 4 reasons Dart is still a language worth learning

  Despite a perception that it is dead, there are a few reasons Dart is still a language worth learning. We explore a few reasons why it may not be as obsolete as some think.  Continue Reading

• 16 REST API design best practices and guidelines

  Common guidelines for API design lead to better functionality and flexibility. Follow these REST API design best practices to help you tend to your burgeoning API garden.  Continue Reading

• The basics of monitoring and observability in microservices

  We examine how monitoring and observability help development teams keep a distributed architecture from coming unraveled by individual failures and performance bottlenecks.  Continue Reading

• API testing checklist and best practices

  Proper API testing isn't just determining if an endpoint is functional. Follow these steps to identify your organization's important APIs, which tests to run, and which tools to use.  Continue Reading

• 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

• 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

• 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 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

• 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

• 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

• 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