Afleveringen
-
Iâm always interested in what factors shape the design of a programming language. This week weâre taking a look at a language thatâs wholly shaped by its need to support a very specific kind of program - audio processing. Anything from creating a simple echo sound effect, to building an entire digital instrument based on a 17th-century harpsichord.
The language in question is Faust, and this week weâre joined by Romain Michon, who works on and teaches Faust, as we look at how itâs designed, what kind of programmers it's for, and how it does the job of turning audio-pipeline definitions into executable code.
And one of the surprising parts of that compilation strategy is the decision to have it compile to multiple targets, from the expected ones like C and Rust, to the exotic destination of FPGAs (Field Programmable Gate Arrays). FPGAs are like reprogrammable circuit boards, and Romain dives into Faustâs attempts to go from a high-level description of an audio program, all the way down to instructions that tell a chip exactly how it should wire itself.
So rather aptly for a technology podcast, we start this week with what your ear can hear and go all the way down to logic gates and circuit boardsâŠ
â
Try Faust in the Browser: https://faustide.grame.fr/
Faust Online Course: https://www.kadenze.com/courses/real-time-audio-signal-processing-in-faust/info
FPGAs: https://en.wikipedia.org/wiki/Field-programmable_gate_array
VHDL: https://en.wikipedia.org/wiki/VHDL
Verilog: https://en.wikipedia.org/wiki/Verilog
Grame: https://www.grame.fr/
The (Strawberry Jam) Gramophone: https://www.grame.fr/articles/gramophone
Gramophone Workshops: https://www.grame.fr/evenements/atelier-gramophones-65ca16b19fec4
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
This week we take a look at what you can do with a GPU when you get away from just using it to draw polygons. AgnĂšs Leroy has spent most of her career programming, optimizing and converting programs to run on that oh-so-curious piece of specialised processing hardware, and we go through all the places that journey has taken her. From simulating the flow of fluids in hydroelectric powerstations, to figuring out how to make a new approach to encryption run fast enough to make it practicalâŠ
â
Become a Developer Voices supporter! https://patreon.com/DeveloperVoices
A Fully Homomorphic Encryption Scheme (pdf): https://crypto.stanford.edu/craig/craig-thesis.pdf
CUDA platform: https://developer.nvidia.com/cuda-zone
Rust-CUDA: https://github.com/Rust-GPU/Rust-CUDA
And in case anyone was wondering, A List of Hydroelectric Power Stations in France: https://en.wikipedia.org/wiki/Category:Hydroelectric_power_stations_in_France
â
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
Zijn er afleveringen die ontbreken?
-
OCaml has one of the best-loved compilers available, and parts of it are surprisingly pluggable, so itâs not surprising that someone would eventually try to wed OCaml with JavaScript and the web browser. In fact, the ecosystem has gone further, and there are now a bevvy of options for people who want to write OCaml and run it in the browser, or want to write OCaml in the browser, or want to write something that looks like JavaScript but runs OCaml on the backend.
Joining me to explore the OCaml-meets-JavaScript world is Antonio Montiero. Heâs a key maintainer/contributor for Melange and ReasonML, as well as several other interesting OCaml web projects.
We kick off by discussing the benefits of OCaml and how it clicked with him personally, before we dive into how and why the compiler is being adapted and tweaked to take it to a whole new audience of web-hungry developers.
â
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join
Sponsor Antonioâs Work: https://github.com/sponsors/anmonteiro/
â
The OCaml Platform: https://ocaml.org/platform
OCaml on Discord: https://discuss.ocaml.org/t/ocaml-discord-server/1884
ReasonML: https://reasonml.github.io/en/
What is Melange? https://melange.re/v4.0.0/what-is-melange.html
Melange for React Devs: https://react-book.melange.re/
The Melange Playground: https://melange.re/v4.0.0/playground/
js_of_ocaml: https://github.com/ocsigen/js_of_ocaml
FUN OCaml Conference: https://fun-ocaml.com/
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
Mapping is a hugely complex task to take on. Even if you moved as much of the data-management as you can out to 3rd-party services, youâd still have a tonne of work to do weaving together map tiles, routing information, GPS data, points of interest, search and more. And as if that wasnât enough, youâd probably want that software to work on a whole range of platforms, so you have to build something that works on iOS, Android and more. Itâs little wonder that the space is dominated by a few closed-source projects owned by huge companies with near-limitless resources.
But that doesnât mean the problem canât be cracked as an open-source project. This week we look at the open source map library Ferrostar. Joining me to discuss it is the projectâs lead developer, Ian Wagner, as we explore the problem space and dive down into Ferrostarâs architecture: A core Rust library serving a suite of custom UI shells written in Kotlin, Swift, WASM and TypeScript.
Along the way there are tips for anyone attempting to build a map, or wanting to interop Rust with other languages.
â
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join
Ferrostar on Github: https://github.com/stadiamaps/ferrostar
Ferrostar user guide: https://stadiamaps.github.io/ferrostar/
MapLibre: https://maplibre.org/
Project OSRM: https://project-osrm.org/
Dioxus (Rust UI framework): https://dioxuslabs.com/
Slint: https://slint.dev/
UniFFI (repo): https://github.com/mozilla/uniffi-rs
UniFFI (user guide): https://mozilla.github.io/uniffi-rs/latest/
Beeline (navigation device): https://beeline.co/
Ian on Mastodon: https://fosstodon.org/@ianthetechie
Ian on Twitter: https://x.com/ianthetechie
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
The terminal might be the most used development tool in history. So itâs a little odd that it hasnât changed that much in the decades since the terminal first came into being. Is the terminal a âcompletedâ project? Or are there new ways to look at it that might make it even more useful?
This weekâs guestâZach Lloydâis convinced the terminal is ripe for a new approach thatâs more than just a new coat of paint. And in this episode we dive into what that approach is, what heâs trying to do with the Warp Terminal, and how itâs put together using a combination of Rust and GPU shaders.
Along the way we look at what LLMs could do to improve the terminal experience, where the boundary lies between terminal and shell, and where Go has solved some problems and created others over at Warp HQ.
â
Become a Supporter on Patreon: https://patreon.com/DeveloperVoices
Become a Supporter on YouTube: https://www.youtube.com/@developervoices/join
Warp Homepage: https://app.warp.dev/referral/VQGWW3
VT100 Information: https://vt100.net/
Game of Life in Rust: https://github.com/krisajenkins/game-of-life-rust
Zed (Text editor in Rust): https://zed.dev/
Flutter: https://flutter.dev/
The Painterâs Algorithm: https://en.wikipedia.org/wiki/Painter%27s_algorithm
Zach on LinkedIn: https://www.linkedin.com/in/zachlloyd/
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
â
0:00 Intro
2:22 Why Create A New Terminal?
7:28 Blurring the Lines Between Terminal and Shell
16:04 How Do You Build A Terminal Program?
24:55 Implementing a Terminal in Rust
30:32 Rust Frameworks for GPU Shaders
40:04 Will Any Of This Go Open Source?
42:49 Managing a Mixture of Rust and Go
47:52 Whatâs the DX of Warp?
51:43 Integrating LLMs into the Terminal
1:05:58 Outro
-
A languageâs ASTâitâs abstract syntax treeâis nearly always a hidden implementation detail. Itâs not treated as part of the language, but merely the intermediate step between parsing and compiling. But this weekâs guest aims to flip that relationship on its head...
Peter Saxton joins me to talk about EYG - an AST-first language that defines the fundamental capabilities first, and then stretches out from there to surface syntax and final execution.
The result is something that can teach us a lot about how a typed, functional programming language works; how an extensible effects system works; and could make writing a new programming language as easy as defining the syntax you want, and parsing that into EYG's AST.
--EYG Homepage: https://github.com/crowdhailer/eyg-lang
TinyGo: https://tinygo.org/
Become a Supporter on Patreon: https://patreon.com/DeveloperVoices
Become a Supporter on YouTube: https://www.youtube.com/@developervoices/join
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
DuckDBâs become a favourite data-handling tool of mine, simply because it does so many small things well. It can read and write a huge number of data formats; it can infer schemas automatically when you just want to move quickly; and it can interface with most languages, run like lightning on the desktop or be embedded into a webpage. Iâm a huge fan.
But Iâm not nearly as knowledgeable as this weekâs two fans, Simon Aubury and Ned Letcher, whoâve just written a book on all the many ways you can use DuckDB and all the hidden tricks and tips that help you make the most of this. So in this episode weâre taking a practical look at DuckDB, what problems it can solve at work, and how to start getting the most out of it.
â
Getting Started with DuckDB (book): https://packt.link/byKYt
DuckDB episode with Hannes MĂŒhleisen: https://youtu.be/pZV9FvdKmLc
DuckDB: https://duckdb.org/
dplyr, the data-manipulation language: https://dplyr.tidyverse.org/
duckplyr, DuckDBâs ânativeâ version: https://github.com/duckdblabs/duckplyr
Substrait: https://substrait.io/
Observable (Markdown+DuckDB=Reports): https://observablehq.com/framework/
DuckDBâs âfriendlyâ SQL: https://duckdb.org/docs/sql/dialect/friendly_sql.html
Community Extensions: https://community-extensions.duckdb.org/
DuckCon #5: https://duckdb.org/2024/08/15/duckcon5.html
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join
Simon on Twitter: https://x.com/SimonAubury
Ned on Twitter: https://x.com/nletcher
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
RRWeb is based on a simple idea: If you capture all the DOM events in a browser session, and when they happened, you could play it back later. Play it back for diagnosing error conditions, for understanding your userâs journey, or for creating demo videos that can be edited element-by-element instead of frame-by-frame.
Unfortunately, the simple idea gets tricky when you try to implement, for a whole host of browser specific glitches, differences, and places where the HTML5 spec ran out. Itâs exactly the kind of project where might want to use it, but you want someone else to maintain it!
Joining us this week is Justin Halsallâa chief contributor to rrwebâto teach us about some of the more barren corners of the browser spec, how heâs fought through them, and what the benefits are on the other sideâŠ
â
RRWeb homepage: https://www.rrweb.io/
RRWeb on Github: https://github.com/rrweb-io/rrweb
RecordOnce: https://recordonce.com/
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join
Justin on Twitter: https://x.com/juice10
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
â
0:00 Intro
3:10 What is rrweb Doing?
6:12 Beginning With A Naive Implementation
9:49 Supporting Canvas Tags
13:05 Exotic HTML 5 Tags Like Midi
14:31 The Internal Data Format
17:39 How Reliable Can This Be In Practice?
23:04 Cross-Browser Support
24:32 Exploring The Use Cases
30:17 Privacy Issues
33:46 Analyzing User Interactions En-Masse
36:40 Is The Spec Greater Than The Tool?
38:20 The Practical Benefits Of Contributing To Open Source
44:45 Updating Recordings After The Website Changes
49:55 Playing Well (Or Badly) With Popular Frameworks
53:21 The Runtime Burden
54:17 What's Coming In The Future?
1:01:02 Outro
-
The ZigLang team have put an astonishing amount of effort into making Zig work an effective tool for compiling C across different architectures. Work that benefits the Zig language, but also has a chance to benefit languages like Python and Rust. Or indeed, any language that uses native C libraries somewhere in its stack.
So this week weâre joined by Loris Cro of the Zig team to dive into how you make a reliable, cross-platform toolchain that can compile C anywhere it finds it. And in doing so,
â
Zig Homepage: https://ziglang.org/
Zig on Github: https://github.com/ziglang/zig
MingW for Windows: https://www.mingw-w64.org/
All Your Codebase: https://allyourcodebase.com/
Ziglang on PyPi: https://pypi.org/project/ziglang/
Shout out to Whitequark: https://pypi.org/user/whitequark/
Darling: https://www.darlinghq.org/
WineHQ: https://www.winehq.org/
PyPi Stats: https://pypistats.org/packages/__all__
The Zine static site generator: https://zine-ssg.io/
The Zine source code: https://github.com/kristoff-it/zine
Lorisâ website: https://kristoff.it/
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
Back in 2012, JosĂ© Valim started building Elixir to as a way to have his ideal programming language running on the same platform as Erlang. Fast-forward 12 years and itâs become build anything from distributed infrastructure to notebooks and websites.
In this weekâs Developer Voices, JosĂ© joins us to tell the history of Elixir in a series of design choices. Which features mattered to him in the early days, and which ones excite him most now. Whatâs going on under the hood to make Elixir tick, and what does its future hold?
â
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@developervoices/join
Elixir Homepage: https://elixir-lang.org/
Elixir Docs: https://elixir-lang.org/docs.html
Numerical Elixir: https://github.com/elixir-nx
Phoenix: https://phoenixframework.org/
Livebook: https://livebook.dev/
JosĂ©âs Livebook & Elixir Presentation: https://www.youtube.com/watch?v=pas9WdWIBHs
Comparing Elixir & Erlang Variables: https://dashbit.co/blog/comparing-elixir-and-erlang-variables
Gleam on the BEAM: https://youtu.be/RntfkL8lUY4
José on Github: https://github.com/josevalim
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
Thereâs huge pressure on Python at the moment to get faster, ideally without changing at all. One increasinglyâpopular way of achieving that impossible task is to push the performance critical code down into C, C++, or Rust. And this week weâre focussing on the Python route, as we take a look at PyO3.
David Hewittâs the principal committer to PyO3, and he joins us to go through the easy parts, the hard parts, and the works in progress, giving us an insight into how Python and Rust work under the hood, and quite how much work it takes to make them work as one.
â
PyO3 User Guide: https://pyo3.rs/v0.22.0/
PyO3 on Github: https://github.com/PyO3/pyo3
Polars: https://pola.rs/
Tokio: https://tokio.rs/
Trio: https://trio.readthedocs.io/
Robyn: https://github.com/sparckles/Robyn
Faster CPython: https://github.com/faster-cpython
Maturin: https://www.maturin.rs/
â
David on Mastodon: https://fosstodon.org/@davidhewitt
David on Twitter: https://x.com/davidhewittdev
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://x.com/krisajenkins
-
Most message systems have an opinion on the right way to do inter-systems communication. Whether itâs actors, queues, message logs or just plain olâ request response, nearly every tool has decided on The Right Way to do messaging, and it optimises heavily for that specific approach. But NATS is absolutely running against that trend.
In this weekâs episode, Jeremey Saenz joins us to talk about NATS, the Cloud Native Computing Foundationâs configurable message-passing and data-transfer system. The promise is a tool that can happily behave like a queue for one channel, a log like another and a request/response protocol for the third, all with a few client flags.
But how does that work? Whatâs it doing under the hood, what features does it offer, and what do we lose in return for that flexibility? Jeremy has all the answers as we ask, what is NATS really?
â
NATS on Github: https://github.com/nats-io/nats-server
NATS Homepage: https://nats.io/
Getting Started with NATS: https://youtu.be/hjXIUPZ7ArM
Developer Voices Episode on Benthos: https://youtu.be/labzg-YfYKw
CNCF: https://www.cncf.io/
The Ballerina Language: https://ballerina.io/
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
Support Developer Voices via Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices via YouTube: https://www.youtube.com/@developervoices/join
-
Smalltalk is one of those programming languages thatâs lived out of the mainstream, but often referenced as an influence and an important part of programming history. Itâs the cornerstone of object-oriented programming, it was into message passing before actors were cool, and it blurs the line between operating system, programming language and personal notebook. But what is it?
Joining us to discuss it is Juan Vuletich, the creator of one of Smalltalkâs latest incarnations, Cuis. In this episode we cover Smalltalkâs history, its design ideas, Cuisâs unique implementation and what makes this modern implementation something special.Smalltalk is over 50 years old, but its vision of how computing could work has only begun. Letâs see if we can mine some ideas from it to take us into the next generation of computing...
--
The Cuis Smalltalk Book: https://cuis-Smalltalk.github.io/TheCuisBook/Preface.htmlCuis on Github: https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev
The Cuis Community: https://cuis.st/community
A Short History of Cuis: https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev/blob/master/Documentation/CuisHistory.md
Monticello VCS: https://wiki.squeak.org/squeak/1287
Juanâs Music Research: https://www.jvuletich.org/research.html
Back to the Future - The Story of Squeak (pdf): https://dl.acm.org/doi/pdf/10.1145/263700.263754
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
This week we take a close look at the language Inko from two perspectives: The language design features that make it special, and the realities of being a language developer.
Yorick Peterse joins us to discuss why heâs building Inko, and which design sweetspots heâs looking for. We begin with memory management, aiming for the kind of developer who wants control, but without the complexities of Rust. Then we look at the designing for concurrency with typed channels, and handling exceptions by removing them and leaning heavily into ADTs and pattern matching.
Mixed in with all that is a discussion on the realities of being a programming language developer. How do you figure out how to implement your ideas? What tradeoffs do you make and what kind of programmer do you want to be most useful to? How do you teach people new ideas in programming, and how âdifferentâ can you make a language before it feels weird? And perhaps the hardest question of all: How do you fund a new programming language in 2024?
â
Inkoâs Homepage: https://inko-lang.org/
Yorickâs Homepage: https://yorickpeterse.com/
Ownership You Can Count On (paper): https://inko-lang.org/papers/ownership.pdf
âThe Error Modelâ: https://joeduffyblog.com/2016/02/07/the-error-model/
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
Iâve often wondered how you build a text editor. Like many software projects, itâs a simple idea at the core with an almost infinite scope for features. How do you build a solid foundation to expand on? Which features matter for launch? And how do you hope to satisfy the needs of every programmer, working in every language?
My guest for this episode is Nathan Sobo. Heâs tackled this problem once before with the Atom editor, and heâs back older & wiser with Zed - a new editor written completely from scratch in Rust. It has a modern UI, a wide spread of language support, and a completely different way of looking at team collaboration. But with so much ambition, what are Zedâs priorities, and whatâs been left for a future version?
--
Zed Homepage: https://zed.dev/
Segment Trees: https://en.wikipedia.org/wiki/Segment_tree
Ropes: https://en.wikipedia.org/wiki/Rope_(data_structure)
Rust Executors: https://rust-lang.github.io/async-book/02_execution/04_executor.html
More about Roc: https://youtu.be/DzhIprQan68
More about TigerBeetle: https://youtu.be/ayG7ltGRRHs
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
This week on Developer Voices weâre talking to Ryan Worl, whose career in big data engineering has taken him from DataDog to Co-Founding WarpStream, an Apache Kafka-compatible streaming system that uses Golang for the brains and S3 for the storage.
Ryan tells us about his time at DataDog, along with the things he learnt from doing large-scale systems migration bit-by-bit, before we discuss how and why he started WarpStream. Why re-implement Kafka? What are the practical challenges and cost benefits of moving all your storage to S3? And would he choose Go a second time around?--
WarpStream: https://www.warpstream.com/
DataDog: https://www.datadoghq.com/
Ryan on Twitter: https://x.com/ryanworl
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
PostgreSQL is an incredible general-purpose database, but it canât do everything. Every design decision is a tradeoff, and inevitably some of those tradeoffs get fundamentally baked into the way itâs built. Take storage for instance - Postgres tables are row-oriented; great for row-by-row access, but when it comes to analytics, it canât compete with a dedicated OLAP database that uses column-oriented storage. Or can it?
Joining me this week is Philippe NoĂ«l of ParadeDB, whoâs going to take us on a tour of Postgresâ extension mechanism, from creating custom functions and indexes to Rust code that changes the way Postgres stores data on disk. In his journey to bring Elasticsearchâs strengths to Postgres, heâs gone all the way down to raw datafiles and back through the optimiser to teach a venerable old dog some new data-access tricks.
â
ParadeDB: https://paradedb.com
ParadeDB on Twitter: https://twitter.com/paradedb
ParadeDB on Github: https://github.com/paradedb/paradedb
pgrx (Postgres with Rust): https://github.com/pgcentralfoundation/pgrx
Tantivy (Rust FTS library): https://github.com/quickwit-oss/tantivy
PgMQ (Queues in Postgres): https://tembo.io/blog/introducing-pgmq
Apache Datafusion: https://datafusion.apache.org/
Lucene: https://lucene.apache.org/
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
The actor model is a popular approach to building scalable software systems. And isnât hard to understand when youâre just reading about the beginnerâs examples. But how do you architect a complex design using the actor model? Which patterns work well? How do you think through it?
Joining me to take us through it is Hugh McKee. Hughâs a total actor-model fan, and a Developer Advocate for Lightbend (the company that created the popular actor framework Akka). He takes us from his definition of actors to the designs heâs worked on, the patterns heâs found most useful, and the interesting meeting-point between actor-based designs and event-based ones.
â
Wikipedia - Actor Model: https://en.wikipedia.org/wiki/Actor_model
Hughâs book, Designing Reactive Systems: https://go.lightbend.com/designing-reactive-systems-role-of-actor-model
Hugh on Twitter: https://twitter.com/mckeeh3
Hugh on LinkedIn: https://www.linkedin.com/in/mckeehugh
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Kris on Twitter: https://twitter.com/krisajenkins
-
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
- Laat meer zien