Showing 12 out of 12 results


Expert Talk: Functional Programming

Learn from Russ Olsen and Christian Romney why you should look into functional programming. They explore the nature of the paradigm as well as its advantages and misconceptions. In this GOTO Unscripted, Russ Olsen shares his war stories and explains how functional programming influences his code for the better.

April 5, 2022

The Ideal Programming Language

What would your ideal programming language look like? Erik Doernenburg, head of technology at Thoughtworks, and Richard Feldman, author of “Elm in Action,” sat together at GOTO Copenhagen 2021 to chat about what theirs would look like. They also had a look into the future of up-and-coming languages.

February 8, 2022

Expert Talk: Zig Programming Language and Linters

This conversation between Jeroen Engels, a software engineer at CrowdStrike, and Andrew Kelley, the president and lead software developer of the Zig Software Foundation, discusses the use of linters in programming languages. They talk about the challenges of refactoring code with custom macros and the need for improved refactoring tools and integration with compilers for programming languages. The conversation also covers the importance of error codes versus warning codes in linters, handling potentially null values, and the tradeoffs of having linting errors. Although the Zig compiler does not have a separate linter, they agree that a separate linter step from the compilation step is a viable option. The conversation highlighted the importance of enforcing linting in the continuous integration (CI) process and the need for programmers to cooperate to make functions work without side effects.

April 28, 2023

Upgrade Your Front-end Game – Be an Elm Wizard

Elm is a purely functional language that compiles to Javascript in less than 4 seconds. We sat down with Richard Feldman, author of the book "Elm in Action" to understand how learning to code in Elm can help software developers whether they work with it on a daily basis or not.

July 3, 2020

GOTO Book Club Yule Special

2020 has indeed been a different year. Many good things have happened, but the year has also shown that the world needs us more than ever. Software has a huge global impact and power and responsibility should go hand in hand, which unfortunately is not always the case. We've chatted with Martin Fowler, Richard Feldman, Mike Amundsen, Dave Thomas, Erik Schön, Saša Jurić, Casey Rosenthal, and Aino Vonge Corry about what was good in 2020 and how we can make 2021 better.

December 23, 2020

The Best of GOTO Book Club Part One

When is the last time you read a programming book? Has it helped you with your career? Check out some of the highlights of the GOTO Book Club and immerse yourself in the next level of your professional development: - Elixir - Elm - Clean Architecture - Containers - Retrospectives - Continuous Architecture Stay tuned for the next episodes.

November 18, 2021

Rust in Action

Rust in Action introduces the Rust programming language by exploring numerous systems programming concepts and techniques. You'll be learning Rust by delving into how computers work under the hood. You'll find yourself playing with persistent storage, memory, networking and even tinkering with CPU instructions. The book takes you through using Rust to extend other applications and teaches you tricks to write blindingly fast code. You'll also discover parallel and concurrent programming. Filled to the brim with real-life use cases and scenarios, you'll go beyond the Rust syntax and see what Rust has to offer in real-world use cases. Richard Feldman, author of Elm in Action, goes over the benefits of this multi-paradigm, high-level, general-purpose language together with Tim McNamara, author of Rust in Action.

March 30, 2023

Introducing Elm to a JavaScript App

Have you wanted to try Elm on a JavaScript project, but rewriting the whole code base was out of the question? With the right techniques, you won't need a rewrite! By the end of this talk you'll know how to introduce Elm to a JavaScript app incrementally, so you don't have to wait for a blank canvas. First we'll cover some Elm basics (in case you've never used it) as well as some benefits a programmer—or manager!—might get out of it. Then we'll get into the nuts and bolts of introducing Elm to an existing JavaScript code base, covering rendering, business logic, and the details in between. Come see how easily you can get started with Elm—not on your next project, but on the project you already have!


Elm on The Backend

Elm is a functional language with a focus on simplicity and friendly error messages. Research in functional programming has made guarantees like "no runtime errors" possible since the 1970s, and I wanted to bring those kinds of guarantees to the browser in a way that would feel fun and accessible. Over the first decade of Elm usage, companies created webapps of up to 600k lines, confidently making large changes and additions to their codebase without introducing any runtime errors. In 2019, after a decade of work, I felt like the remaining avenues for serious improvement all centered on details of the server and database. I began to explore what "Elm on the Backend" might look like. Can I store Elm types directly in the database? Can I guarantee no SQL injection? No N+1 patterns? Can I avoid GC pauses entirely? How will it work with frontend Elm code? This is the first real preview of this exploration so far! NOTE: My goal is to get some early feedback from the in-person audience, so the video will be held back for now. I am not announcing a release, and [the roadmap](https://github.com/elm/compiler/blob/master/roadmap.md) and [this status update](https://discourse.elm-lang.org/t/status-update-3-nov-2021/7870) are still the primary documents for long-time Elm users to set expectations about this work.


Why Static Typing Came Back

The 1990s birthed Python, Ruby, PHP, and JavaScript - dynamic programming languages that went on to be extremely popular. Today, each has a widely used static type-checker: mypy, Sorbet, Hack, and TypeScript. By RedMonk rankings, the most popular languages released in the past 15 years have been TypeScript, Go, Kotlin, Swift, Dart, and Rust - all statically typed. If a generation of popular dynamically typed languages grew out of dissatisfaction with 1990s-era statically typed languages, what changed? Is it a matter of fashion, and the pendulum will soon swing back to favoring dynamic again? Is gradual typing the future, because it promises the best of both worlds? If so, then why aren't Go, Kotlin, Swift, or Rust gradually typed? (Dart was originally, and later changed to static!) Why has static typing made such a comeback in the past decade? And what does it mean for the future? This talk dives into all of these questions, and more!