2022 - Eric Feminella

Native Data Categorization with Object.groupBy

The introduction of Object.groupBy allows for a streamlined, native approach to organizing collections of data based on user defined criterion; thus simplifying the task of data analysis and categorization without the need for managing third-party dependencies.

Using Object.groupBy

Using Object.groupBy is simple and straight-forward. If you have previously used Lodash groupBy, then you are already familiar with it’s API. Object.groupBy accepts an array and a callback function which defines the grouping logic, and returns an object of groupings based on the callback function’s returned key.

For example, we can group employees by department as follows:

Example 1

const employees = [

{id: 123, department: 'Engineering', name: 'John Doe', doh: '12/22/20'},

{id: 321, department: 'Product', name: 'Jane Smith', doh: '06/12/19'},

{id: 213, department: 'Product', name: 'Fred Jones', doh: '03/13/12'},

{id: 312, department: 'Engineering', name: 'Kim Tyler', doh: '12/19/21'},

];

const departments = Object.groupBy(employees,({department}) => department);

console.log(departments);

// {

// Engineering: [

// {id: 123, department: 'Engineering', name: 'John Doe', ...},

// {id: 312, department: 'Engineering', name: 'Kim Tyler', ...}

// ],

// Product: [

// {id: 321, department: 'Product', name: 'Jane Smith', ...},

// {id: 213, department: 'Product', name: 'Fred Jones', ...}

// ]

// }

In the above example, we see that the provided array can easily be grouped into specific properties, in this case, by department. We can just as easily have grouped the array by any other property as well, such as date of hire (doh) to categories by employee tenure (more on this shortly ).

Indeed, Object.groupBy is particularly useful for grouping collections of objects; however, it is not restricted to objects alone, it can also be used to create grouping primitives as well:

Example 2

const values = [true, false, true, true, false];

const {enabled, disabled} = Object.groupBy(

values, value => value ? 'enabled' : 'disabled'

);

console.log(enabled.length); // 3

console.log(disabled.length); // 2

While the above examples are useful in their own right, the real power of Object.groupBy is revealed when more complex logic is required for determining groupings. For example, we can group the employees array by tenure as follows:

Example 3

const employees = [

{id: 123, department: 'Engineering', name: 'John Doe', doh: '12/22/20'},

{id: 321, department: 'Product', name: 'Jane Smith', doh: '06/12/19'},

{id: 213, department: 'Product', name: 'Fred Jones', doh: '03/13/12'},

{id: 312, department: 'Engineering', name: 'Kim Tyler', doh: '12/19/21'},

];

const groupByTenure = (employees, target) => {

const year = (1000 * 60 * 60 * 24 * 365.25);

return Object.groupBy(employees,({doh}) => {

const tenure = (target - new Date(doh)) / year;

return (

tenure > 1 ? (

tenure <= 2 ? 'development' : 'retention'

) : 'onboarding'

)

})

};

console.log(

groupByTenure(employees, new Date('11/28/22'))

);

// {

// "development": [{

// "id": 123,

// "department": "Engineering",

// "name": "John Doe",

// "doh": "12/22/20"

// }],

// "retention": [{

// "id": 321,

// "department": "Product",

// "name": "Jane Smith",

// "doh": "06/12/19"

// }, {

// "id": 213,

// "department": "Product",

// "name": "Fred Jones",

// "doh": "03/13/12"

// }],

// "onboarding": [{

// "id": 312,

// "department": "Engineering",

// "name": "Kim Tyler",

// "doh": "12/19/21"

// }]

// }

Concluding Thoughts

New features such as Object.groupBy serve to highlight the TC39 Committee’s commitment to providing developers with powerful tools which simplify common tasks. By introducing a native facility for grouping objects, Object.groupBy simplifies overhead and maintainability while also opening up new opportunities for native data aggregation and analysis.

Update: November 28, 2023: Object.groupBy is now currently in Stage 4 status.

Comments Off

Simplified Error Handling with Error Causes

Exception handling is a critical aspect to ensuring the reliability and resilience of a system. Perhaps of equal importance is the ability for developers to easily debug exception traces back to a root cause. In JavaScript, however, traditionally this process has often required rather convoluted solutions which lead to intricate patterns that ultimately continued to obscure the underlying root cause. Fortunately, with the introduction of the error.cause property, JavaScript debugging has now taken a significant step forward towards simplifying this process, providing native capabilities which facilitate improved error traceability.

Legacy Error Handling

In the legacy paradigm, JavaScript’s error handling was akin to a labyrinth, often requiring developers to traverse a complex maze of stack traces in order to pinpoint the origin of an issue. This often necessitated verbose logging mechanisms, which, while somewhat effective, still lacked fundamental standardization and tended to introduce additional layers of complexity which must be integrated within a system, and understood by team members.

Historical Workarounds

While error cause contexts have been available in numerous other languages such as Rust/WASM, Python, etc. in JavaScript, historically speaking, such a facility has been unavailable. Thus, to mitigate these short-comings, developers would need to resort to basic workarounds such as appending custom properties to re-thrown errors or appending error messages. Although these solutions provided a makeshift bridge to identify error causes, they were rather convoluted at best, and often led to fragmented and inconsistent implementation which never truly solved the problem at hand.

Native Error Support

The error.cause property heralds a new era, providing a streamlined approach to attach and propagate the underlying cause of an error, offering a standardized approach for encapsulating the origin of subsequent errors.

Consider the traditional approach where a custom property might have been used to include information related to the originating error:

Example 1

try {

// operation that may fail ...

} catch (err: Error) {

// create a new error instance and augment with a rootCause which

// references the original error

const error = new Error(...);

error.rootCause = err;

throw error;

}

With error.cause, the same can be now achieved natively while retaining the full stack trace back to the origin root cause:

Example 2

try {

// operation that may fail ...

} catch (err: Error) {

// include the original error as the subsequent error's cause ...

throw new Error('Failed due to network issues', {cause: err});

}

Benefits of Leveraging Error Cause

The benefits of adopting error.cause are manifold, resulting in a significant improvement to Developer Experience though native error traceability. A few key benefits include:

Clarity: Provides a clear lineage of errors, akin to a well-documented review process, making it much easier to understand the flow of exceptions.

Consistency: Promotes a more uniform error handling mechanism across applications.

Simplicity: Reduces the need for additional error handling constructs, streamlining error propagation and handling.

Concluding Thoughts

As with countless other language enhancements, the introduction of the error.cause property is a testament to JavaScript’s evolution, offering developers a robust and simplified error handling mechanism; supporting more reliable facility for error tracing, reshaping the way debugging and exception management can be approached.

January 14, 2022 APIs / Browsers / ES+ / JavaScript / Software Engineering

Comments Off