What We Learned at JSConf Budapest 2022

This summer, ABBYY was a proud sponsor of JSConf Budapest—an international conference bringing together JavaScript enthusiasts from all over the world. Six people from the ABBYY Hungary team, including myself, were representing the company at the event. During the two-day conference, we got to talk to hundreds of developers from as far afield as Singapore, Israel, Serbia, the UK, and many other locations. A steady stream of visitors attended our booth where everyone could take our fun (but not so easy) quiz and win prizes, while learning about ABBYY. We also had the opportunity to listen to dozens of great speakers, and collected some interesting thoughts and insights to share in this post*.

The Power of JS Generators by Anjana Vakil

In this presentation, Anjana shared her passion about generators with the audience with so much energy that even if you didn’t know anything about generators, you were instantly hyped up!

The presentation started with a brief introduction to generators. In case your generator-related knowledge is a little bit rusty, here's a link to refresh your memory, but I advise you to watch Anjana's presentation instead, which has it all covered.

Iterables

Generator functions are also iterables which means we can loop through them, and we can use, for example, the spread operator:

function* abcs() {

    yield 'a';

    yield 'b';

    yield 'c';

}

[...abcs()]; // ['a', 'b', 'c']

In the presentation there was a neat example about a French card deck object with the special property [Symbol.iterator] and the presenter used the fact that generators are also iterable so that when we spread the deck object, the internal iterator of the object, which is a generator function, creates all the French deck cards. This presentation helped us to think out-of-the-box about generators and their practical uses in our applications.

Here you can watch the full presentation.

Typed JavaScript? For Real? The “Type Annotations” Proposal and What It’s All About by Gil Tayar

Gil presented a TC39 proposal on including types in vanilla JavaScript. The proposal currently is in the first stage, so anything can happen still, but the idea behind types in JavaScript is not uncommon—just think about TypeScript or Flow.

But we have TypeScript! – you might think.

Yes, but the proposal aims to provide a common alternative to TypeScript in which you don't necessarily have to transpile your code.

The types would still be ignored by the runtime, similar to how TypeScript works, and the types would be applied by annotations with similar syntax to TypeScript.

Internally, we had an interesting conversation about this topic. In itself, this doesn't provide anything more than just using TypeScript. However, diversity is always welcome, and another option for typed JavaScript is, again, very good. We are very curious about how this proposal will evolve.

Here you can watch the full presentation.

Communicating Intention with Functional TypeScript by Thiago Temple

This presentation by Thiago caught our attention for several reasons:

1. a) we use TypeScript extensively here at ABBYY;
2. b) let's face it, when it comes to typing, we developers can be lazy 😊

So hearing some advice, tips and tricks is always helpful. The “gotcha” moment for us in this presentation was to put more focus on typing, not just for the positive scenario but for (controlled) failures as well. I'm pretty sure all of you are familiar with code (pseudo) like this:

type Order = {...}

type OrderResult = Result<ProcessedOrder>

function processOrder(order: Order): OrderResult {}

The upper code is quite standard, but what if we throw from the function, or what happens if the order is null ? Maybe the function handles the missing input, in which case it returns a different result. Thiago reminded us to handle those edge-cases as well. Here is an example from the presentation:

type Order = {...}

type OrderResult = Result<ProcessedOrder, OrderProcessingError>

function processOrder(order: Order): OrderResult {}

The speaker also talked about using union types when the input for the function is a well-defined finite set of string values. One way this helps us is to catch typo errors. Here at ABBYY we use union types all the time, so it was nice to learn a little more about them.

Here you can watch the full presentation.

7±2 Reasons Psychology Will Help You Write Better Code by Moran Weber

This was a really exciting talk, and I encourage all of you to watch the video and play along with the little “games”. Moran has a degree in social psychology along with a lot of experience in software development. She shared several cognitive psychology principles that help to better understand how we read and interpret code.

For example, it is common knowledge among developers to use meaningful naming of variables, functions, etc. We all know the requirements. But do we really understand why good naming yields better collaboration? While shamelessly I would reply “yes”, in reality I did not. This presentation explains and demonstrates this extremely well.

One other thing that sticks in my mind and that I have practiced with my team since the conference is that code reviews should always be cold. This means no design explanation and intro is needed before handing your code—just send out a pull request. Otherwise, we could fall into a selective attention trap and not stay objective while reviewing the code.

Here you can watch the full presentation.

Testing Web Accessibility by Adrián Bolonio

Adrián spoke about web accessibility. At ABBYY Hungary we are working on a web application for ABBYY Timeline—a cloud-based process intelligence platform that helps companies improve their processes. The target audience does not include every day users rather, per se, superusers such as business analysts. We don't have to think about web accessibility (which is usually referred to as a11y), the target audience just does not require this, right? WRONG. And Adrián explains very well why my statement is so wrong.

According to the presenter, every web application should care about accessibility. It is so easy to consider a11y as something we have to think about only when the target audience includes people with disabilities. Well, what if I tell you this mindset is wrong, and we all should care about a11y regardless of the type of application we are making? Adrián showed us that not only disabled people might use our applications leveraging a11y capabilities, like screen readers or other aids, but people with temporary inconveniences may also need them. For example, a father having his kid on his lap (sounds familiar in the era of home office?) and being able to use the application with only one hand. Or a worker having some temporary eye strain, which can happen to any of us.

This talk was influential—I could even say eye-opening!—to many of us attending the conference. The presentation has given us ideas and inspiration about the direction in which we want to develop the product we are working on.

Here you can watch the full presentation.

*All presentations in the program were insightful, and we enjoyed each one of them. The upper excerpts reflect our team's best memories about the conference.

Conclusion

For me, personally, this was the first JSConf I was able to attend here in Budapest. I felt the focus was more on the less technical aspects of web development rather than straight technical JavaScript, which was an advantage. This way topics like web accessibility and psychology could gain some love and attention. Huge thanks to the JSConf Budapest team for organizing the conference.