Conference Report #

In January 2017, Linz hosted one of its first major international JavaScript conferences: Script’17. The event took place on 27 January and was organized by Stefan and Sebastian together with the local developer community. It was a one-day conference, fully focused on JavaScript and the surrounding ecosystem. Despite its compact format, it brought together an impressive lineup of speakers from well-known companies and projects.

Format and Atmosphere #

Script’17 was a single-track event with a full-day schedule. The timing was slightly unusual compared to larger conferences: it started around midday and ran into the evening. This made it easier for attendees to travel in and out on the same day, especially for those coming from Austria and nearby regions. The atmosphere felt informal but very focused. There was less of the “big conference” feeling and more of a community-driven setup. At the same time, the quality of speakers made it clear that this was an international-level event, not just a local meetup.

Speaker Lineup and Highlights #

One of the strongest aspects of Script’17 was the speaker lineup. It included people who had a direct influence on widely used technologies in the JavaScript ecosystem.

JavaScript is a buffet, not the enemy (Chris Heilmann) #

The keynote was delivered by Chris Heilmann, a well-known figure in web development and at that time working on Microsoft Edge. His talk focused less on technical details and more on developer culture and mindset. The central idea was that JavaScript is not something to fight against, but something to use responsibly and flexibly.

Some key ideas from the talk:

• Use tools that make you productive, but don’t dismiss others’ choices
• Avoid forcing opinions or frameworks on others
• Invest time in learning and teaching
• Be critical of unrealistic job requirements (like outdated experience demands)

It was a reflective talk about how developers interact with technology and each other. The “buffet” analogy did not resonate equally with everyone, but the underlying message was solid and relevant.

Evolution of a Web Application (Raquel Velez) #

Raquel Velez from npm gave a look behind the scenes of the npm website and its evolution.

It was interesting to learn that npm, despite being widely used, was still a relatively small company at the time, with around 20 employees. Their product challenges included:

• Search as a surprisingly hard problem for a package registry
• Scaling a rapidly growing open-source platform
• Managing a complex testing setup across multiple tools

She also discussed how npm uses different testing frameworks and tools in parallel, including Karma, node-tap, and Selenium-based solutions. One small but memorable detail was npm’s internal “wombat” theme, which even made its way into stickers and UI elements.

Introduction to Serverless (Nik Graf) #

Nik Graf presented the serverless paradigm, based on frameworks like AWS Lambda and Azure Functions.

The talk explained serverless as another abstraction layer in system architecture:

• Physical servers
• Virtual machines
• Containers
• Serverless functions

The core idea: developers focus on functions, while infrastructure is fully managed.

While the concept was presented in a clean and structured way, the talk felt more like a high-level introduction than a deep technical exploration. At the time, serverless also felt somewhat overhyped, with strong promises around scalability and simplicity.

The Long Road to 1.0 (Hannah Wolfe) #

One of the more insightful talks came from Hannah Wolfe, CTO of Ghost. She shared the long development journey of the Ghost blogging platform, including:

• The original Kickstarter funding (~230k€)
• Architectural decisions over several years
• The difficulty of scaling a growing open-source project

Some interesting challenges included:

• Deciding between SPA and server-rendered architecture
• Managing module boundaries in a large Node.js codebase
• Handling multiple database systems and eventual trade-offs
• Choosing a frontend framework through community discussion

A particularly strong takeaway was their principle:

Solve real problems first, DRY later

The talk stood out because it was honest about real-world engineering trade-offs, not just polished success stories.

Building Apps with Electron (Felix Rieseberg) #

Felix Rieseberg from Slack introduced Electron and demonstrated how desktop applications can be built using web technologies.

Electron combines Node.js and Chromium, enabling cross-platform desktop apps.

Key points:

• Separation between main and renderer processes
• IPC (inter-process communication) abstraction
• Access to native APIs like file systems
• Framework-agnostic frontend layer (React, Angular, etc.)

The live coding session was especially engaging, building a small demo app using the Monaco editor and Electron APIs.

At the time, Electron was already powering Slack itself, which served as a strong real-world validation of the technology.

Performance Profiling for V8 (Franziska Hinkelmann) #

One of the most technical talks was delivered by Franziska Hinkelmann, a member of the Google V8 team. This session went deeper than most conference talks typically do. It covered:

• Chrome DevTools performance profiling
• Inline caches (ICs) and object shape optimization
• JavaScript engine internals and optimization strategies
• Deoptimization scenarios in V8
• Even generated machine code examples

A key takeaway was how much complexity is hidden behind seemingly simple JavaScript operations. At one point, the idea was emphasized that:

Compiler optimization is just code

This was a refreshing reminder that even deep systems like JavaScript engines are ultimately understandable if you invest the time to study them.

Art.js (Mathieu Henri) #

Mathieu Henri closed the technical program with a creative live coding session focused on generative art. Coming from a demoscene background, the talk was less about frameworks and more about raw creation:

• Procedural generation using mathematical functions
• Canvas-based animation systems
• Audio-reactive visualizations using the Web Audio API

The result was a live-coded system combining visuals and sound into a generative experience. It was less a lecture and more a performance.

Personal Impression #

Script’17 was a surprisingly strong conference for its size and location. The speaker lineup was particularly impressive, including engineers from Microsoft (Edge), Slack (Electron), npm, and Google (V8 team). For a one-day event in Linz, the level of expertise was unexpectedly high. At the same time, the compact format had trade-offs:

• Limited time for deeper discussions
• Little room for social events or evening networking
• Focus on talks rather than extended community interaction

Still, this made it very accessible. It was easy to attend, easy to follow, and easy to leave with new ideas in a single day.

Conclusion #

Script’17 showed that even a relatively small, local conference can attract top-tier speakers and deliver meaningful technical content. The combination of JavaScript ecosystem topics, strong engineering talks, and creative sessions made the event diverse and engaging. For a first edition in Linz, it was an impressive start and clearly demonstrated the strength of the local developer community.