How to implement API pagination patterns for single and composite result sets

When surfacing data from systems of record, one of the concerns designers and developers need to address is the potential of retrieving an enormous number of results in a single load session. This requires significant processing power on both the client and server sides and network traffic, and can degrade the overall data consumption and experience.

There are different approaches to address this concern, but one of the most widely used is the concept of pagination.

How to mitigate unhappy paths with an event-driven architecture at scale

The reality of supporting production event-driven architecture at any reasonable scale is that it can be challenging, especially when dealing with bad events and unhappy paths, both of which affect business operations and the customer experience. Architects and developers often focus on delivering the minimum viable product (MVP) to show business value early and validate the approach taken. While focusing on the MVP can be valuable in establishing IT agility — the requirements are targeted at normal operation,

8 challenges of API landscapes

One of the key tasks of supporting a vital API program for your company is dealing with change over time. In previous articles, I’ve talked about the importance of managing the entire API lifecycle and how to recognize important milestones in the life of an API. These milestones often signal that a change in the way the API is treated, measured, and managed needs to change. 

3 tips for driving API consumption: APIs Unplugged

In this episode, Mike and Matt are joined by special guest Stephen Fishman, Regional Vice President of Customer Success Architecture at MuleSoft and longtime API product expert. Stephen shares insights on product-oriented approaches to API design, development, and lifecycle management. Topics range from API discoverability to launch strategies to a relentless focus on API consumers. Have a listen here:

Why designing an intentional API consumer experience starts with the users

A close friend and mentor of mine (Patrick Quattlebaum of Harmonic Design) once said “All systems have a design. The question is ‘is the design intentional or random?’” What he meant is that the design of interfaces created inside an enterprise (graphical or not) communicate how much that organization values the time and effort of their users. In addition to functional communication, these interfaces also communicate your enterprise’s commitment to low-friction experiences.

MUnit for Java Programmers: Test execution

Unit tests are executed at different stages during the development life cycle. As mentioned in the first blog post of this series, MUnit for Java Programmers: Introduction, unit tests play an essential role in the implementation, maintenance, and evolutionary stages of a project’s life cycle. Tests can be executed during each of these stages and the results are collected and analyzed. Should the application pass the series of tests it will continue on its journey through the project’s lifecycle.

MUnit for Java Programmers: Test doubles

What are test doubles?

A test double is a term used to describe replacing a dependent component of the functionality that is being tested with a dummy version of the real component — similar to a stunt double, only for unit tests. The test double only needs to emulate the behavior of the original dependent component closely enough that the functionality being tested doesn’t detect it’s not using the real component.

MUnit for Java Programmers: Test fixtures

February 26 2020

0 comments

Test fixtures, also known as a test context, sets up the conditions for a test to run. These test conditions will be a known good state that is specific to the code under test. When the test is completed, the state is restored or torn down. Conditions can be set up before a test suite executes and before a test runs. Test suites are extended further by parameterizing executions, enabling the same test to run different inputs. 

MUnit for Java Programmers: Test Assertions

February 20 2020

0 comments

At the heart of unit tests are assertions which provide a mechanism for comparing expected outcomes with actual outcomes. JUnit provides a large selection of overloaded convenience methods that perform predefined logical assertions, such as testing for equality, negations, and conditions specified by a matcher. MUnit also provides a similar set of assertion capabilities such as to assert two values as equals, validate a logical condition, and a variety of other custom assertions that replicate familiar JUnit assertions.

An introduction to MUnit for Java programmers

February 13 2020

0 comments

Unit tests are an integral part of the software development lifecycle. However, for most it is a task that must be endured and compounded by what seem like arbitrary test coverage targets.

In this blog, I will introduce MUnit by making reference to concepts already familiar to Java developers, thereby making the transition to MuleSoft developer and architect smoother.