Developer Voices

Bytewax is a curious stream processing tool that blends a Python surface with a Rust core to produce something that's in a similar vein to Kafka Streams or Apache Flink, but with a fundamentally different implementation. This week we're going to take a look at what it does, how it works in theory, and how the marriage of Python and Rust works in practice… – The original Naiad Paper: https://dl.acm.org/doi/10.1145/2517349.2522738 Timely Dataflow: https://github.com/TimelyDataflow/timely-dataflow Bytewax the Library: https://github.com/bytewax/bytewax Bytewax the Service: https://bytewax.io/ PyO3, for calling Rust from Python: https://pyo3.rs/v0.21.2/ Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins -- #softwaredevelopment #dataengineering #apachekafka #timelydataflow

Mojo is the latest language from the creator of Swift and LLVM. It's an attempt to take some of the best techniques from CPU/GPU-level programming and package them up in a Python-compatible syntax. In this episode we explore why Mojo was created, and what it offers to Python programmers and non-Python programmers alike. How is it built for performance, and which performance features matter? What's its take on functional programming and type systems? And can it marry the high-level programming of Python with the low-level programming of LLVM/MLIR? If you're a Python programmer who needs better performance, a C programmer who expects more from a 'scripting language', or just someone who'd be happier if Python had a first-class type system, Mojo might well be for you… – Mojo: https://www.modular.com/max/mojo Mojo's Roadmap: https://docs.modular.com/mojo/roadmap.html The Mojo Discord: https://discord.com/invite/modular MLIR: https://mlir.llvm.org/ Chris's Talks: https://nondot.org/sabre/Resume.html#talks Chris on Twitter: https://twitter.com/clattner_llvm Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins – #software #podcast #mojolang #ml #pythonml

Every database has to juggle the need to process new data and to query old data. That task falls to any system that "does stuff and remembers stuff". But it's quite hard to really optimise one system for both use cases. There are different constraints on new and old data, and as a system gets larger and larger, those differences multiply to breaking point. That's something Twitter's engineers were figuring out in the 2010s. One solution that came up in those years was the Lambda Architecture. A two-pronged approach that recognises the divide between new and old data, and works hard to blend the two together seamlessly in userspace. But that seamless blending is easier said than done. It's nearly all bespoke work. What if you could get it off the shelf? Let someone else do the work of combining two different kinds of database into one neat package? That's the question of the week as we look at the recently open-sourced project Proton, and its attempt to be the Lambda Architecture in a box… – Proton Docs: https://docs.timeplus.com/proton Proton Source: https://github.com/timeplus-io/proton Timeplus: https://www.timeplus.com/ Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins – #podcast #softwareengineering #databases #dataengineering

Rust changed the discussion around memory management - this week's guest hopes to push that discussion even further. This week we're joined by Evan Ovadia, creator of the Vale programming language and collector of memory management techniques from far and wide. He takes us through his most important ones, including linear types, generation references and regions, to see what Evan hopes the future of memory management will look like. If you've been interested in Rust's borrow-check and want more (or want different!) then Evan has some big ideas for you to sink your teeth into. – Vale: https://vale.dev/ The Vale Discord: https://discord.com/invite/SNB8yGH Evan's Blog: https://verdagon.dev/home Evan's 7DRL Entry: https://verdagon.dev/blog/higher-raii-7drl 7DRL: https://7drl.com/ https://verdagon.dev/grimoire/grimoire What Colour Is Your Function?: https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/ 42, the language: https://forty2.is/ Verona Language: https://www.microsoft.com/en-us/research/project/project-verona/ Austral language: https://austral-lang.org/ Surely You're Joking, Mr Feynman! (book): https://www.goodreads.com/book/show/35167685-surely-you-re-joking-mr-feynman Evan on Twitter: https://twitter.com/verdagon Find Evan in the Vale Discord: https://discord.com/invite/SNB8yGH Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins – #software #programming #podcast #valelang

The "big data infrastructure" world is dominated by Java, but the data-analysis world is dominated by Python. So if you need to analyse and process huge amounts of data, chances are you're in for a less-than-ideal time. The impedance mismatch will probably make your life hard somehow.  So there are a lot of projects and companies trying to solve that problem. To bridge those two worlds seamlessly, and many of the popular solutions see SQL as the glue. But this week we're going to look at another solution - ignore Java, treat Kafka as a protocol, and build up all the infrastructure tools you need with a pure Python library. It's a lot of work, but in theory it would make Python the one language for data storage, analysis and processing, at scale. Tempting, but is it feasible?  Joining me to discuss the pros, cons, and massive scope of that approach is Tomáš Neubauer. He started off doing real time data analysis for the Maclaren's F1 team, and is now deep in the Python mines effectively rewriting Kafka Streams in Python. But how? How much work is actually involved in porting those ideas to Python-land, and how do you even get started? And perhaps most fundamental of all - even if you succeed, will that be enough to make the job easy, or will you still have to scale the mountain of teaching people how to use the new tools you've built? Let's find out. –  Quix Streams on Github: https://github.com/quixio/quix-streams Quix Streams getting started guide: https://quix.io/get-started-with-quix-streams Quix: https://quix.io/  Tomáš on LinkedIn: https://www.linkedin.com/in/tom%C3%A1%C5%A1-neubauer-a10bb144 Tomáš on Twitter: https://twitter.com/TomasNeubauer0 Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins   -- #podcast #softwaredevelopment #datascience #apachekafka #streamprocessing

Erlang wears three hats - it's a language, it's a platform, and it's an approach to making software run reliably once it's in production. Those last two are so interesting I sometimes wonder why those ideas haven't been ported to every language going.  How much work would it be? This week we're going to dig right down into that question with Leandro Ostera. He's been working on Riot - a project to bring the best of Erlang's runtime system and philosophy to OCaml. But why OCaml? Is it possible to marry together OCaml's type system with Erlang's dynamic dispatch systems? And what is it about the recent release of OCaml5 that makes the whole project easier? – Leandro's Blog: https://www.abstractmachines.dev/ Why Typing Erlang is Hard: https://www.abstractmachines.dev/posts/am012-why-typing-erlang-is-hard/ Riot: https://riot.ml/ Riot source: https://github.com/riot-ml/riot ReasonML: https://reasonml.github.io/ ReScript: https://rescript-lang.org/ Leandro on Twitter: https://twitter.com/leostera Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins -- #podcast #softwaredevelopment #erlang #ocaml #softwaredesign

The likes of LinkedIn and Uber use Pinot to power some astonishingly high-scale queries against realtime data. The numbers alone would make an impressive case-study. But behind the headline lies a fascinating set of architectural decisions and constraints to get there. So how does Pinot work? How does it process queries? How are the various roles split across a cluster? And equally important - what does it *not* try to achieve. Joining me to go through the nuts and bolts of how Pinot handles SQL queries is Tim Berglund, veteran technology explainer of the realtime-data world. He takes us through Pinot step-by-step, covering the roles of brokers, servers, controllers and minions as we build up the picture of a query engine that's interesting in theory and massively performant in practice. – Apache Pinot: https://pinot.apache.org/ Apache Pinot Docs: https://docs.pinot.apache.org/ StarTree: https://startree.ai/ https://startree.ai/Event Driven Design episode with Bobby Calderwood: https://youtu.be/V7vhSHqMxus Tim on Twitter: https://twitter.com/tlberglund Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins – #podcast #softwaredevelopment #apachepinot #database #dataengineering #sql

TJ DeVries is a core contributor to Neovim and several of its most interesting sub-projects, and he joins us this week to go in depth into how Neovim got started, how it's structured, and what a truly programmable editor has to offer programmers who want the perfect environment. Along the way we look at what we can learn from Neovim's successful fork of the 30-year old codebase from Vim, how it still collaborates with the original project, and what putting Lua at the heart of the system has done for casual tinkerers and hardcore plugin writers alike. Not everyone will come away from this discussion wanting to switch editors, but I'm sure you'll get a newfound appreciation for digging deeper into the developer tools you use everyday. – Neovim: https://neovim.io/ Neovim Kickstarter: https://github.com/nvim-lua/kickstart.nvim Kickstarter walkthrough video: https://www.youtube.com/watch?v=m8C0Cq9Uv9o A directory of Neovim plugins: https://dotfyle.com/ Vimscript's definition of true and false: https://vimhelp.org/eval.txt.html#Boolean TJ on Twitter: https://twitter.com/teej_dv TJ on Twitch: https://www.twitch.tv/teej_dv TJ on YouTube: https://www.youtube.com/@teej_dv Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins – #podcast #software #softwareengineering #dx

Done right, a Hackathon can be a fantastic place to be a programmer - you get time and space to build and learn, in a room full of like-minded people, with swag and prizes to sweeten the deal. It's a great way to pick up new ideas and run with them. But done wrong it can be a waste of time. What's the difference between a good hackathon and a bad one? What do the good ones do right, and what can we learn from that? This week we're talking about the Joy of Hacks with Major League Hacking Co-Founder Jon Gottfried. He's got over 10 years of experience building a Hackathon network that provides the right environment for "structured mucking about with computers", so we're going to pick his brains. If you're ever attending a Hackathon, organising one, or looking for a way to build or contribute to your local programming community, Jon can help guide you to events that work. -- Major League Hacking: https://mlh.io/ Major League Hacking's 2024 Event Calendar: https://mlh.io/seasons/2024/events Games Week: https://events.mlh.io/events/10848  Jon on Mastodon: https://hachyderm.io/@jonmarkgo Jon on LinkedIn: https://www.linkedin.com/in/jonmarkgo Jon on Twitter: https://twitter.com/jonmarkgo Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins Bonus link - The Great American Baking Show 2023: https://www.youtube.com/watch?v=IlWLSAKEedk -- #software #podcast #programming #hackathon

One of the most promising techniques for software reliability is property testing. The idea that, instead of writing unit tests we describe some property of our code that ought to always be true, then have the computer figure out thousands of unit tests that try to break that rule. For example, you might say, "No matter which page you visit on my website, there should always be a login button or a logout button." Then the test's job is to try to break that rule, but clicking around until it finds some combination of clicks fails that assertion. Like, maybe it finds the 404 page, and you realise it was missing the website's normal header. At its best, property testing takes far less work than unit testing, but is far more thorough, because it lets us write the rules and has the computer write the examples. The downside is, it often seems theoretical. It can be hard to apply property testing to real-world cases. Let's fix that. We're joined by Oskar Wickstrom, who's been building all kinds of different systems and bringing property testing with him wherever he goes. We discuss the basics of property testing, then he goes into the advanced and cunning techniques that go beyond the ordinary into testing databases, webpages and more. With a bit of thought, he can help us test a ten times as much code with a tenth of the effort. -- Oskar's book, Property Testing a Screencast Editor [ebook]: https://leanpub.com/property-based-testing-in-a-screencast-editor Quickstrom: https://quickstrom.io/ F# for Fun & Profit: Property Testing Series: https://fsharpforfunandprofit.com/series/property-based-testing/ Linear Temporal Logic: https://en.wikipedia.org/wiki/Linear_temporal_logic The Quickstrom Paper: https://arxiv.org/abs/2203.11532 TodoMVC (One frontend app, many implementations): https://todomvc.com/ Oskar on Twitter: https://twitter.com/owickstrom Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins -- #softwaredevelopment #podcast #programming #testdrivendevelopment #propertytesting

If you ever feel overwhelmed by the number of different programming languages, this week's episode might just offer you some solace, as we talk about an attempt to reunify many of the most popular languages by focussing on the bread & butter things that every language supports. I'm joined by Martin Johansen, who's been working on a new tool called Progsbase. With it, he's created a spec based on all the things programming languages can agree on, and is building a library that can cross-compile between them. Write a program in Java, and it can be automatically translated to PHP, Python and a great deal more. But how far can he take that idea? Is there really enough unity between these languages to build something universal? How do you bridge the divide between manual memory management languages like C and garbage-collected ones like Java? And what would it actually feel like to write code this way? Let's put Martin's plan under the spotlight and find out… – Martin on Twitter: https://twitter.com/martinfj Kris on Twitter: https://twitter.com/krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Progsbase homepage: https://www.progsbase.com/ The Spec: https://www.progsbase.com/docs/programs/ The Progsbase library repository: https://repo.progsbase.com/ The Bug Bounty: https://www.progsbase.com/bug-bounty/ – #software #programming #podcast #programminglanguages

A lot of programming is split into the mechanical work of writing what you know, and the creative work of figuring out what you don't know. Wouldn't it be nice to automate the mechanical stuff away? Well the good news is we're already automating a lot of it. Every time you run a refactoring tool or a pretty-printer, you're handing boring work off to the computer. But how does that magic work, and how can we do more of it? This week we're joined by one of the authors of OpenRewrite—Jonathan Schneider—to learn how automated code-rewriting tools really work. From the basic approach to the hairy corner cases, to the reality of keeping developers happy with the subjective side of the results. It takes a lot of work to automate work away - this week we'll learn how the work gets done for us too. – OpenRewrite: https://docs.openrewrite.org/ Supported Languages: https://docs.openrewrite.org/recipes Moderne: https://www.moderne.io/ Gradle Lint: https://github.com/nebula-plugins/gradle-lint-plugin Chicory (Native JVM WASM): https://github.com/dylibso/chicory Call Java from Haskell: https://github.com/tweag/inline-java#readme Call Haskell from Java: https://github.com/nh2/call-haskell-from-anything Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Twitter: https://twitter.com/krisajenkins – #podcast #software #programming #softwareengineering #refactoring #parsers

SQLite could do with a little competition, so when I invited the co-creator of DuckDB in to talk, I thought we'd be discussing the perils of trying to build a new in-process database engine. I quickly realised things went much deeper than just a tech refresh. Hannes Mühleisen joins me this week to blend his academic credentials as a database researcher with his vehement need to make that research practical. And so we dive into what modern database literature has to say on making queries faster, more parallelizable, and closer to the metal, and how it all comes together in a user-friendly package that's found its way into my day-to-day workload, and might well help out yours. If you're curious about the gory details of database queries, how they can take advantage of modern hardware, or how all that research actually turns into a useful tool, Hannes has some great answers. -- DuckDB: https://duckdb.org/ Database Systems Book: http://infolab.stanford.edu/~ullman/dscb.html Kris' first computer: https://en.wikipedia.org/wiki/File:ZX_Spectrum_Plus2_(retouched).jpg Volcano Query Evaluation System [pdf]: https://paperhub.s3.amazonaws.com/dace52a42c07f7f8348b08dc2b186061.pdf Morsel Query Engine [pdf]: https://cs.brown.edu/~kayhan/papers/morsel_cp.pdf Unnesting Arbitrary Queries [pdf]: https://cs.emis.de/LNI/Proceedings/Proceedings241/383.pdf Papers Hannes' team have published: https://duckdb.org/why_duckdb#peer-reviewed-papers-and-thesis-works DuckDB on Mastodon: https://mastodon.social/@duckdb Kris on Twitter: https://twitter.com/krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Mastodon: https://mastodon.social/@krisajenkins -- #softwaredevelopment #podcast #programming #database #duckdb #sql #sqlite

This week we talk to Simon Peyton Jones, a veteran language designer and researcher, and key figure in the development of Haskell. Haskell. Simon has made countless contributions to advancement of functional programming, and computer programming in general, and is currently working at Epic Games, working on the foundations of their new programming language, Verse. We discuss how programming languages are made, focussing on a big design idea from both Haskell and Verse: building a large language from a small, tightly designed core. Then we move into Simon's current work exploring Functional Logic Programming, the big new idea that underpins Verse. It's an idea that blends the fundamentals FP with the core ideas of logic languages like Prolog in an entirely new way. Not even Simon knows exactly where the idea will lead, but it's a fascinating idea that could potentially bring constraint-solving and deduction right into the heart of modern software. Additionally, Simon discusses his involvement in reshaping the way we teach computing in England. He's been working hard to give computing education the same importance as the teaching of mathematics and sciences - something we should all have a fundamental understanding of. Simon's one of the smartest, nicest people in programming. Come as hear his brilliant brain at work. :-D – Verse: https://github.com/UnrealVerseGuru/VerseProgrammingLanguage The Verse Language Reference: https://dev.epicgames.com/documentation/en-us/uefn/verse-language-reference The Verse Calculus [pdf]: https://simon.peytonjones.org/assets/pdfs/verse-March23.pdf https://en.wikipedia.org/wiki/Simon_Peyton_Jones The LogicT monad: https://hackage.haskell.org/package/logict Can programming be liberated from the von Neumann style?: https://dl.acm.org/doi/10.1145/359576.359579 CAS - Computing At School: https://www.computingatschool.org.uk/ Computer Science Teachers Association: https://csteachers.org/ Kris on Twitter: https://twitter.com/krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

Benthos wants to be part of your Data Engineering toolkit - it's there as a quick and easy way to set up data pipelines and start streaming data out of A and into B. In contrast to a lot of the tools we've talked about on Developer Voices, Benthos seems focussed on cutting development time down to a minimum, so you can quickly configure a new pipeline and test it out, without making a whole sprint of the task. As quick as a quick-and-dirty shell script, without the dirt. 😉 So this week we're talking to the creator of Benthos, Ashley Jeffs, to hear why he created Benthos, what it can do for you, and what its strengths and weaknesses are. And Jeff's refreshingly candid about when you should and shouldn't use it. If you ever need to get data from an HTTP connection into S3, or S3 into Kafka, or Kafka into a flat file, Benthos might just save you a few hours of development. – Benthos: https://www.benthos.dev/ A list of supported inputs, processors & outputs: https://www.benthos.dev/docs/about#components All their cute blobfish logos: https://www.benthos.dev/blobfish/ IDML: https://idml.io/ Kris on Twitter: https://twitter.com/krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ – #software #podcast #dataengineering #datascience

The world of game programming might seem a million miles away from 'regular' programming. But they still have to deal with the same kinds of data, scale and concurrency problems that we're all familiar with in the software world. And that makes the gaming world an interesting place for new ideas - under the hood they're solving those same problems we face, but often with some novel ideas about the solutions.  So this week we're off to the massive open world that is game development, to see what we can learn that might make lives easier in the non-gaming space. Joining us for that is Tyler Cloutier, the founder of Clockwork Labs. They're building SpaceTimeDB, a curiously-distributed database built to be the underlying platform for their new MMORPG, BitCraft. Digging down into the architecture of SpaceTimeDB, we pick Tyler's brain for nuggets of information on event sourcing, request/response vs. subscriptions, transactions, security and much more. All in an effort to make our programmers and data scientists' lives easier. -- SpaceTimeDB: https://spacetimedb.com/ BitCraft: https://bitcraftonline.com/ "4X games" defined: https://en.wikipedia.org/wiki/4X Plan 9 O.S.: https://en.wikipedia.org/wiki/Plan_9_from_Bell_Labs Tyler on LinkedIn: https://www.linkedin.com/in/tylercloutier/ Kris on Twitter: https://twitter.com/krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Mastodon: https://mastodon.social/@krisajenkins -- #programming #podcast #softwaredevelopment #software #gamedev #gamedevelopment

Odin's creator, Bill Hall, makes some bold claims about the language, including that it's "programming done right". Before that starts a war on the internet, we'd best ask him to explain what that means, and how Odin tries to achieve it. And while we get deep into the details, overall his answer seems to be, "By gathering masses of feedback and then refining C until it feels joyous again. Of all the C-like languages we've looked at on Developer Voices, Odin seems to be the most at-ease with its progenitor. It's not trying to be a revolutionary new way of thinking about systems programming; it's just trying to rethink C for modern conventions. If Bill's hit his goals, it might be the most comfortable way to get a language that's C, but C done better… – Odin: https://odin-lang.org/ Odin Packages: https://pkg.odin-lang.org/ Newsqueak [pdf]: https://swtch.com/~rsc/thread/newsqueak.pdf EmberGen: https://jangafx.com/software/embergen/ Raylib: https://www.raylib.com/ RayLib bindings for Odin: https://github.com/odin-lang/Odin/tree/master/vendor/raylib Verse language: https://dev.epicgames.com/documentation/en-us/uefn/verse-language-reference Algorithms + Data Structures = Programs: https://en.wikipedia.org/wiki/Algorithms_%2B_Data_Structures_%3D_Programs Bill on Twitter: https://twitter.com/TheGingerBill Kris on Twitter: https://twitter.com/krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ -- #podcast #software #softwareprogramming #programming #odin #odinlang

This week's guest describes Event Sourcing as, "all I'm going to use for the rest of my career." But what is Event Sourcing? How should we think about it, and how does it encourage us to think about writing software? In this episode we take a close look at systems designed around the idea of Events, with guest Bobby Calderwood. Bobby's been designing (and helping others design) event based architectures for many years, and enthusiastically recommends it not only as a system-design technique, but as a way of solving business problems faster and more reliably. During this discussion we look at the various ways of defining event systems, what tools we need to implement them, and the advantages of thinking about software from an event-based perspective. Along the way we discuss everything from Clojure, Bitemporality & Datomic to Kafka and more traditional databases - all in the service of capturing real-world events and building simple systems around them. – EventStoreDB: https://developers.eventstore.com/ The CloudEvents standard: https://cloudevents.io/ Datomic: https://www.datomic.com/ Adam Dymitruk's Event Modelling Explanation: https://eventmodeling.org/ Bobby's Event Modelling course: https://developer.confluent.io/courses/event-modeling/intro/ Bobby on Twitter: https://twitter.com/bobbycalderwood Boddy on LinkedIn: https://www.linkedin.com/in/bobbycalderwood/ Kris on Twitter: https://twitter.com/krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ – #software #softwarepodcast #programming #eventsourcing #eventdrivenarchitecture #kafka

One of our oldest languages meets one of our newest sciences in this episode, as we talk with Professor Christian Schafmeister, an award-winning nanotech researcher who's been developing a language and a design suite to help research the future molecular machines. In this episode Christian gives us a quick chemistry lesson to explain what his research is trying to achieve, then we get into the software that's doing it: A new flavour of Common Lisp. But why Lisp? What advantages does a 60 year old language design offer? How does he strike a balance between high-level language features and the need for exceptional performance and parallelism?  And what tricks does his development environment have that modern IDEs could still learn a thing or two from? -- Clasp (the Lisp): https://github.com/clasp-developers/clasp Cando (the design language): https://github.com/cando-developers/cando The Feynman Prize: https://en.wikipedia.org/wiki/Feynman_Prize_in_Nanotechnology Alphafold: https://alphafold.ebi.ac.uk/ More on LEaP: https://ambermd.org/tutorials/pengfei/ Interactive Development of Crash Bandicoot: https://all-things-andy-gavin.com/2011/03/12/making-crash-bandicoot-gool-part-9/  Christian's Research Group: https://www.schafmeistergroup.com/ Kris on Twitter: https://twitter.com/krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ -- #programming #software #lisplang #commonlisp #nanotech

Sometimes, what a programming language makes harder is just as important as what it makes easier. For a simple example, think of GOTO. We've been wisely avoiding it for decades because it makes confusing control flow desperately easy. Types and tests are other examples - they're as much about specifying what shouldn't work as what should. And perspective is what makes this week's topic particularly interesting: Roc is a language that's functional, fast, friendly, and extremely interested in making your life easier by enabling some possibilities and restricting others. So this week we're joined by Richard Feldman, the creator of Roc. He's been an advocate of the Elm programming language for years, for its tight focus on taking the best bits of Functional Programming to the browser. And in recent years he's been inspired to build his own language, taking that philosophy to other places and platforms. But which bits are "the best bits"? And how do they change when the domain you're coding for changes? How is Roc built and how would we build systems in it? Let's find out… -- Roc's homepage: https://www.roc-lang.org/ Richard's GOTO Copenhagen 2021 talk: https://www.youtube.com/watch?v=3n17wHe5wEw Richard on Twitter: https://twitter.com/rtfeldman Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ Kris on Mastodon: https://mastodon.social/@krisajenkins Kris on Twitter: https://twitter.com/krisajenkins