Discover the future of software from the people making it happen.Listen to some of the smartest developers we know talk about what they're working on, how they're trying to move the industry forward, and what you can learn from it. You might find the solution to your next architectural headache, pick up a new programming language, or just hear some good war stories from the frontline of technology.Join your host Kris Jenkins as we try to figure out what tomorrow's computing will look like the best way we know how - by listening directly to the developers' voices.
Similar Podcasts
New Rustacean
A show about the Rust programming language and the people who use it.
The Cynical Developer
A UK based Technology and Software Developer Podcast that helps you to improve your development knowledge and career,
through explaining the latest and greatest in development technology and providing you with what you need to succeed as a developer.
Algorithms + Data Structures = Programs
The Algorithms + Data Structures = Programs Podcast (aka ADSP: The Podcast) is an informal podcast inspired by Magic Read Along. We plan to talk about whatever we feel like - algorithms, data structures, programming languages, latest news in tech and more. Feel free to follow us on Twitter at @adspthepodcast.
Solving Git's Pain Points with Jujutsu (with Martin von Zweigbergk)
Git might be the most ubiquitous tool in software development, but that doesn't mean it's perfect. What if we could keep Git compatibility while fixing its most frustrating aspects—painful merges, scary rebases, being stuck in conflict states, and the confusing staging area?This week we're joined by Martin von Zweigbergk, creator of Jujutsu (JJ), a Git-compatible version control system that takes a fundamentally different approach. Starting from a simple idea—automatically snapshotting your working copy—Martin has built a tool that reimagines how we interact with version control. We explore the clever algebra behind Jujutsu's conflict handling that lets you store conflicts as commits and move freely through your repository even when things are broken. We discuss why there's no staging area, how the operation log gives you powerful undo/redo capabilities, and why rebasing becomes trivially easy when you can edit any commit in your history and have changes automatically propagate forward.Whether you're a Git power user frustrated by interactive rebases, someone who's lost work to a botched merge, or just curious about how version control could work differently, this conversation offers fresh perspectives on a tool we all take for granted. And if you're working with large monorepos or game development assets, Martin's vision for the future of Jujutsu might be exactly what you've been waiting for.---Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinJujutsu (JJ): https://github.com/martinvonz/jjJujutsu Documentation: https://martinvonz.github.io/jj/Git: https://git-scm.com/Mercurial: https://www.mercurial-scm.org/Rust: https://www.rust-lang.org/Watchman: https://facebook.github.io/watchman/Google Piper: https://research.google/pubs/why-google-stores-billions-of-lines-of-code-in-a-single-repository/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Getting New Technology Adopted (with Dov Katz)
Getting new technology adopted in a large organization can feel like pushing water uphill. The best tools in the world are useless if we're not allowed to use them, and as companies grow, their habits turn into inertia, then into "the way we've always done things." So how do you break through that resistance and get meaningful change to happen?This week's guest is Dov Katz from Morgan Stanley, who specializes in exactly this challenge - driving developer productivity and getting new practices adopted across thousands of developers. We explore the art of organizational change from every angle: How do you get management buy-in? How do you build grassroots developer enthusiasm? When should you use deterministic tools like OpenRewrite versus AI-powered solutions? And what role does open source play in breaking down the walls between competing financial institutions?Whether you're trying to modernize a legacy codebase, reduce technical debt, or just get your team to try that promising new tool you've discovered, this conversation offers practical strategies for navigating the complex dynamics of enterprise software development. Because sometimes the hardest part of our job isn't writing code - it's getting permission to write better code.---Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinMorgan Stanley: https://www.morganstanley.com/OpenRewrite: https://docs.openrewrite.org/Spring Framework: https://spring.io/Spring Integration: https://spring.io/projects/spring-integrationApache Camel: https://camel.apache.org/FINOS (FinTech Open Source Foundation): https://www.finos.org/Linux Foundation: https://www.linuxfoundation.org/Moderne (Code Remix conference organizers): https://www.moderne.io/Code Remix Conference: https://www.moderne.io/eventsKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
From Unit Tests to Whole Universe Tests (with Will Wilson)
How confident are you when your test suite goes green? If you're honest, probably not 100% confident - because most bugs come from scenarios we never thought to test. Traditional testing only catches the problems we anticipate, but the 3am pager alerts? Those come from the unexpected interactions, timing issues, and edge cases we never imagined.In this episode, Will Wilson from Antithesis takes us deep into the world of autonomous testing. They've built a deterministic hypervisor that can simulate entire distributed systems - complete with fake AWS services - and intelligently explore millions of possible states to find bugs before production. Think property-based testing, but for your entire infrastructure stack. The approach is so thorough they've even used it to find glitches in Super Mario Brothers (seriously).We explore how deterministic simulation works at the hypervisor level, why traditional integration tests are fundamentally limited, and how you can write maintainable tests that actually find the bugs that matter. If you've ever wished you could test "what happens when everything that can go wrong does go wrong," this conversation shows you how that's finally becoming possible.---Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinAntithesis: https://antithesis.com/Antithesis testing with Super Mario: https://antithesis.com/blog/sdtalk/...and with Metroid: https://antithesis.com/blog/2025/metroid/MongoDB: https://www.mongodb.com/etcd (Linux Foundation): https://etcd.io/Facebook Hermit: https://github.com/facebookexperimental/hermitRR (Record-Replay Debugger): https://rr-project.org/T-SAN (Thread Sanitizer): https://clang.llvm.org/docs/ThreadSanitizer.htmlToby Bell's Strange Loop Talk on JPL Testing: https://www.youtube.com/results?search_query=toby+bell+strange+loop+jplAndy Weir - Project Hail Mary: https://www.goodreads.com/book/show/54493401-project-hail-maryAndy Weir - The Martian: https://www.goodreads.com/book/show/18007564-the-martianAntithesis Blog (Nintendo Games Testing): https://antithesis.com/blog/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Building Render: Inside a Modern Cloud Platform (with Anurag Goel)
How would you build a Heroku-like platform from scratch? This week we're diving deep into the world of cloud platforms and infrastructure with Anurag Goel, founder and CEO of Render.Starting from the seemingly simple task of hosting a web service, we quickly discover why building a production-ready platform is far more complex than it appears. Why is hosting a Postgres database so challenging? How do you handle millions of users asking for thousands of different features? And what's the secret to building infrastructure that developers actually want to use?We explore the technical challenges of building enterprise-grade services—from implementing reliable backups and high availability to managing private networking and service discovery. Anurag shares insights on choosing between infrastructure-as-code versus configuration, why they built on Go, and how they handle 100 billion requests per month.Plus, we discuss the impact of AI on platform adoption: Are LLMs already influencing which platforms developers choose? Will hosting platforms need to actively support agentic workflows? And what does the future hold for automated debugging?Whether you're curious about building your own platform, want to understand what really happens behind your cloud provider's dashboard, or just enjoy hearing war stories from the infrastructure trenches, this episode has something for you.–Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinRender: https://render.com/Render’s MCP Server (Early Access): https://render.com/docs/mcp-serverPulumi: https://www.pulumi.com/Victoria Metrics: https://victoriametrics.comLoki: https://vector.dev/docs/reference/configuration/sinks/loki/Vector: https://vector.dev/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
InfluxDB: The Evolution of a Time Series Database (with Paul Dix)
What happens when you need to rewrite a database three times? Paul Dix knows firsthand—and he's brutally honest about every mistake along the way.As CTO and co-founder of InfluxData, Paul has navigated the treacherous waters of building a time series database that can handle billions of rows a day. But this isn't your typical founder success story. This is one of the most candid conversations you'll ever hear about what really happens when you're building infrastructure software: how the problems evolve faster than your solutions, how business reality collides with technical vision, and why the challenges you think you need to solve often aren't the ones that matter.Paul walks through InfluxDB's evolution from Go to Rust with unflinching honesty about what went wrong. The custom storage engines (TSM trees) that seemed brilliant until they hit production workloads. The rewrite that solved infinite cardinality and analytics queries—problems customers were asking for—while accidentally breaking the fast time series queries they actually needed. The usage-based pricing model that customers hated, the multi-tenant architecture that created quality-of-service nightmares, and the period where they were literally losing money on every customer.This is a masterclass in how startup problems compound and evolve. Start with a time series database, realize you need better compression, build custom storage engines, discover customers want SQL, rewrite everything in Rust, find out Parquet integration doesn't work like advertised, learn that what people ask for isn't what they use, and end up maintaining three different database versions simultaneously while figuring out pricing models that don't bankrupt you.Paul's transparency is remarkable—from technical decisions to business pivots to the personal challenge of staying hands-on as a founder. If you want to understand what building infrastructure software actually looks like, beyond the polished conference talks and success stories, this conversation is essential.--Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinInfluxData: https://www.influxdata.com/InfluxDB: https://www.influxdata.com/products/influxdb/DataFusion: https://datafusion.apache.org/DataFusion Episode: https://www.youtube.com/watch?v=8QNNCr8WfDMApache Arrow: https://arrow.apache.org/Apache Parquet: https://parquet.apache.org/BoltDB: https://github.com/boltdb/boltLevelDB: https://github.com/google/leveldbRocksDB: https://rocksdb.org/Gorilla: A Fast, Scalable, In-Memory Time Series Database (Facebook paper): https://www.vldb.org/pvldb/vol8/p1816-teller.pdfPaul on LinkedIn: https://www.linkedin.com/in/pauldix/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Beyond AI Hype, What Will Developers Actually Use? (with Zach Lloyd)
If AI coding tools are here to stay, what form will they take? How will we use them? Will they be just another window in our IDE, will they push their way to the centre of our development experience, displacing the editor? No one knows, but Zach Lloyd is making a very interesting bet with the latest version of Warp.In this deep dive, Zach walks us through the technical architecture behind agentic development, and how it's completely changed what he & his team have been building. Warp has gone from a terminal built from scratch, to what they're calling an "agentic development environment" - a tool that weaves AI agents, a development, a shell and a conversation into a single, unified experience. This may be the future or just one possible path; regardless it's a fascinating glimpse into how our tools might reshape not just how we code, but how we experience programming itself.Whether you're all-in on agentic coding, a skeptic, or somewhere in between, AI is here to stay. Now's the time to figure out what form it's going to take.# Support Developer Voices- Patreon: https://patreon.com/DeveloperVoices- YouTube: https://www.youtube.com/@DeveloperVoices/join-- Episode Links- Warp Homepage: https://warp.dev/- Warp Pro Free Month (promo code WARPDEVS25): https://warp.dev/- Previous Warp Episode: https://youtu.be/bLAJvxUpAcg- SWE-bench: https://www.swebench.com/- TerminalBench: https://github.com/microsoft/TerminalBench- Model Context Protocol (MCP): https://modelcontextprotocol.io/- Claude Code: https://claude.ai/code- Anthropic Claude: https://claude.ai/- VS Code: https://code.visualstudio.com/- Cursor: https://cursor.sh/- Language Server Protocol (LSP): https://microsoft.github.io/language-server-protocol/# Connect- Zach on LinkedIn: https://www.linkedin.com/in/zachlloyd/- Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social- Kris on Mastodon: http://mastodon.social/@krisajenkins- Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
The $500 Billion Integration Problem, And One Possible Solution (with Marty Pitt)
Ever wondered why data integration is still such a nightmare in 2025? Marty Pitt has built something that might finally solve it.TaxiQL isn't just another query language - it's a semantic layer that lets you query across any system without caring about field names, API differences, or where the data actually lives. Instead of writing endless mapping code between your microservices, databases, and APIs, you describe what your data *means* and let TaxiQL figure out how to get it.In this conversation, Marty walks through the “All Powerful Spreadsheet” moment that sparked TaxiQL, how semantic types work in practice, and why this approach might finally decouple producers from consumers in large organizations. We dive deep into query execution, data lineage, streaming integration, and the technical challenges of building a system that can connect anything to anything.If you've ever spent months mapping fields between systems or maintaining brittle integration code, this one's for you.–Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/join–TaxiLang Homepage: https://taxilang.org/TaxiLang Playground: https://playground.taxilang.org/examples/message-queue-and-databaseTaxi Lang GitHub repository: https://github.com/taxilang/taxilangOpenAPI Specification (formerly Swagger): https://swagger.io/specification/YOW! Conference - Australian software conference series: https://yowconference.com/Spring Framework Kotlin support: https://spring.io/guides/tutorials/spring-boot-kotlin/Ubiquitous Language (DDD Concept): https://martinfowler.com/bliki/UbiquitousLanguage.htmlKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/–0:00 Intro
Making Software Crash Before It Breaks (with Isaac Van Doren)
At 23, Isaac is already jaded about software reliability - and frankly, he's got good reason to be. When your grandmother can't access her medical records because a username change broke the entire system, when bugs routinely make people's lives harder, you start to wonder: why do we just accept that software is broken most of the time?Isaac's answer isn't just better testing - it's a whole toolkit of techniques working together. He's advocating for scattering "little bombs" throughout your code via runtime assertions, adding in the right amount of static typing, building feedback loops that page you when invariants break, and running nightly SQL queries to catch the bugs that slip through everything else. All building what he sees as a pyramid of software reliability.Weaving into that, we also dive into the Roc programming language, its unique platform architecture that tailors development to specific domains. Software reliability isn’t just about the end user experience - Roc feeds in the idea we can make reliability easier by tailoring the language domain to the problem at hand.–Isaac’s Homepage: https://isaacvando.com/Episode on Property Testing: https://youtu.be/wHJZ0icwSkcProperty Testing Walkthrough: https://youtu.be/4bpc8NpNHRcSupport Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinIsaac on LinkedIn: https://www.linkedin.com/in/isaacvando/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Making Apache Kafka Diskless (with Filip Yonov & Josep Prat)
How do you retrofit a clustered data-processing system to use cheap commodity storage? That’s the big question in this episode as we look at one of the many attempts to build a version of Kafka that uses object storage services like S3 as its main disk, sacrificing a little latency for cheap, infinitely-scalable disks.There are several companies trying to walk down that road, and it’s clearly big business - one of them recently got bought out for a rumoured $250m. But one of them is actively trying to get those changes back into the community, as are pushing to make Apache Kafka speak object storage natively.Joining me to explain why and how are Josep Prat and Filip Yonov of Aiven. We break down what it takes to make Kafka’s storage layer optional on a per-topic basis, how they’re making sure it’s not a breaking change, and how they plan to get such a foundational feature merged.–Announcement Post: https://aiven.io/blog/guide-diskless-apache-kafka-kip-1150Aiven’s (Temporary) Fork, Project Inkless: https://github.com/aiven/inkless/blob/main/docs/inkless/README.mdKafka Improvement Process (KIP) Articles: KIP-1150: https://cwiki.apache.org/confluence/display/KAFKA/KIP-1150%3A+Diskless+Topics KIP-1163: Diskless Core: https://cwiki.apache.org/confluence/display/KAFKA/KIP-1163%3A+Diskless+Core KIP-1164: Topic Based Batch Coordinator: https://cwiki.apache.org/confluence/display/KAFKA/KIP-1164%3A+Topic+Based+Batch+Coordinator KIP-1165: Object Compaction for Diskless: https://cwiki.apache.org/confluence/display/KAFKA/KIP-1165%3A+Object+Compaction+for+DisklessSupport Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinFilip on LinkedIn: https://www.linkedin.com/in/filipyonovJosep on LinkedIn: https://www.linkedin.com/in/jlprat/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Java's Cutting Edge Comeback (with Josh Long)
Java’s has been evolving faster than any 30 year old language has a right to do, and there’s probably no-one more pleased about it than my guest this week - Josh Long. He’s a Java & Kotlin programming, a JVM enthusiast in general, and an advocate for Spring, and he has chapters full of news about what’s been happening in Javaland over the past few years. Everything from new threading models to C interop changes, custom primitives to high performance computing and all the ways in which Java is modernising for age of AI workloads.If you’re out of touch with the latest in the JVM, or don’t know how much its changed, Josh’s brain is full of all the news you need to catch up.–Project Valhalla (Value Objects): https://openjdk.org/projects/valhalla/Project Panama (JVM’s new native code support): https://openjdk.org/projects/panama/Jextract: https://github.com/openjdk/jextractSpring Initializer: http://start.spring.io/Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
The State & Future of Apache Kafka (with Anatoly Zelenin)
I’m joined this week by one of the authors of Apache Kafka In Action, to take a look at the state of Kafka, event systems & stream-processing technology. It’s an approach (and a whole market) that’s had at least a decade to mature, so how has it done? What does Kafka offer to developers and businesses, and which parts do they actually care about? What have streaming data systems promised and what have they actually delivered? What’s still left to build?–Apache Kafka in Action: https://www.manning.com/books/apache-kafka-in-actionPat Helland, Data on the Inside vs Data on the Outside: https://queue.acm.org/detail.cfm?id=3415014Out of the Tar Pit: https://curtclifton.net/papers/MoseleyMarks06a.pdfMartin Kleppmann, Turning the Database Inside-Out: https://martin.kleppmann.com/2015/11/05/database-inside-out-at-oredev.htmlData Mesh by Zhamak Dehghani: https://www.amazon.co.uk/Data-Mesh-Delivering-Data-Driven-Value/dp/1492092398Quix Streams: https://github.com/quixio/quix-streamsXTDB: https://xtdb.com/Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinAnatoly’s Website: https://zelenin.de/Kris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins
DataFusion - The Database Building Toolkit (with Andrew Lamb)
Building a database is a serious undertaking. There are just so many parts that you have to implement before you even get to a decent prototype, and so many hours of work before you could begin working on the ideas that would make your database unique. Apache DataFusion is a project that hopes to change all that, but building an extensible, composable toolkit of database pieces, which could let you build a viable database extremely quickly, and then innovate from that starting point. And even if you’re not building a database, it’s a fascinating project to explain how databases are built.Joining me to explain it all is Andrew Lamb, one of DataFusion’s core contributors, and he’s going to take us through the whole stack, how it’s built and how you could use it. Along the way we cover everything from who’s building interesting new databases and how you manage a large, open-source Rust project.–DataFusion Homepage: https://datafusion.apache.org/DataFusion on Github: https://github.com/apache/datafusionDataFusion Architecture (with diagrams!): https://youtu.be/NVKujPxwSBA?si=tw9ACxlbdpBuVsnv&t=1045Datalog: https://docs.racket-lang.org/datalog/Tokio: https://tokio.rs/Andrew’s Homepage: http://andrew.nerdnetworks.org/Andrew’s Blog Post about Tokio: https://thenewstack.io/using-rustlangs-async-tokio-runtime-for-cpu-bound-tasks/Velox: https://velox-lib.io/Arroyo: https://www.arroyo.dev/Synnada: https://www.synnada.ai/LanceDB: https://lancedb.com/SDF+DBT: https://docs.sdf.com/integrations/dbt/integratingSupport Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Jupyter's Architecture Unpacked (with Afshin Darian & Sylvain Corlay)
Jupyter’s become an incredibly popular programming and data science tool, but how does it actually work? How have they built an interactive language execution engine? And if we understand the architecture, what else could it be used for?Joining me to look inside the Jupyter toolbox are Afshin Darian and Sylvain Corlay, two of Jupyters long-standing contributors and project-steerers. They’ve going to take us on a journey that starts with today’s userbase, goes through the execution protocol and ends with a look at what Jupyter will be in the future - an ambitious framework for interactive, collaborative applications and more.–Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinJupyter Homepage: https://jupyter.org/Jupyter Xeus: https://github.com/jupyter-xeus/xeusJupyter AI: https://github.com/jupyterlab/jupyter-aiJupyter CAD: https://github.com/jupytercad/JupyterCADJupyter GIS: https://github.com/geojupyter/jupytergis/Jupyter GIS Announcement: https://blog.jupyter.org/real-time-collaboration-and-collaborative-editing-for-gis-workflows-with-jupyter-and-qgis-d25dbe2832a6QGIS: https://qgis.org/ZeroMQ: https://zeromq.org/Sylvain on LinkedIn: https://www.linkedin.com/in/sylvaincorlayDarian on LinkedIn: https://www.linkedin.com/in/afshindarianKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Nix, The Build-Everything Language (with Julian Arni)
Ever since we invented makefiles, the programming world has been wrestling with the problem of building software stacks reliably. This week we’re going to look at one of the most ambitious solutions available - Nix. Nix tries to do everything from invoking your compiler to installing your language, and even providing your operating system. But how does it work in theory, and how well does it work in practice?Joining me to discuss is Julian Arni, a Nix-enthusiast and creator of a build/test/deploy service called Garnix.Nix has been one of my go-to tools for years - I hope it’ll find its way into your stack.–Nix Overview: https://nixos.org/explore/Nix Tutorial: https://nix.dev/tutorials/first-steps/Nix Flakes: https://nixos.wiki/wiki/FlakesThe Nix Package List: https://search.nixos.org/packagesGarnix.IO: https://garnix.io/Julian’s NixCon Talk, Call by Hash: https://www.youtube.com/watch?v=fU9ogB9hZZASupport Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
Image Editing as a Syntax Tree (with Keavon Chambers & Dennis Kobert)
Graphite is a new image editor with an interesting architecture - it’s a classic UI-driven app, an image-manipulation language, and a library of programmable graphics primitives that any Rust coder could use, extend or add to. The result is something that you can use like Photoshop or Inkscape, or make use of in batch pipelines, a bit like ImageMagick.Joining me to discuss it are Keavon Chambers & Dennis Kobert, who are hammering away on building a project that’s potentially as demanding as Photoshop, but with a more ambitious architecture. How can they hope to compete? Perhaps in the short term by doing what regular image And is the future of image editing modular?–Graphite Homepage: https://graphite.rs/Graphite Web Version: https://editor.graphite.rs/Signed Distance Fields: https://jasmcole.com/2019/10/03/signed-distance-fields/Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/