Elixir Wizards

Supervised State Replication in Elixir with Micah Cooper

podcast@smartlogic.io (SmartLogic LLC) — Thu, 07 May 2026 06:00:00 -0400

In Season 15 episode 2, Elixir Wizards Sundi Myint and Charles Suggs chat with Micah Cooper to talk about distributed systems, data replication, and what it actually looks like to build these ideas in Elixir.

Micah shares his journey from Ruby to Elixir and walks us through Visor, a library he’s building based on the Viewstamps replication algorithm. Inspired by systems like TigerBeetle, Visor explores how you can replicate state across nodes using GenServers, giving you fault tolerance and recovery without relying entirely on traditional database patterns.

We talk about the difference between distributed systems and data replication, where things tend to get misunderstood, and what changes when you start thinking about state this way. The conversation also touches on event sourcing, tradeoffs in system design, and how Elixir’s distributed model makes some of these concepts more approachable than you might expect.

Along the way, we talk about building for curiosity, experimenting with new ideas, and how projects like this push the ecosystem forward.

Topics discussed in this episode:

Building Visor and working with the Viewstamps replication model
Replicating GenServer state across nodes
Distributed systems vs. data replication
Lessons from TigerBeetle and financial system design
Event sourcing challenges and tradeoffs
Rethinking database-first architectures
Snapshotting, recovery, and fault tolerance
The role of Elixir’s distributed model
Experimentation, learning, and building for curiosity

Links mentioned:

Micah’s GitHub https://github.com/mrmicahcooper
Micah’s GitLab https://gitlab.com/mrmicahcooper
The Visor repository: https://gitlab.com/mrmicahcooper/visor
Visor Hex Package https://hex.pm/packages/visor
Ruby on Rails https://rubyonrails.org/
Phoenix LiveView Framework https://www.phoenixframework.org/
Zig Programming Language https://ziglang.org/
TigerBeetle https://tigerbeetle.com/
TigerBeetle internal docs https://github.com/tigerbeetle/tigerbeetle/tree/main/docs/internals
The BEAM https://www.erlang-solutions.com/blog/the-beam-erlangs-virtual-machine/
GenServer https://hexdocs.pm/elixir/GenServer.html
Apache Kafka https://github.com/apache/kafka
RabbitMQ https://www.rabbitmq.com/
Redpanda https://www.redpanda.com/
SQL https://www.ibm.com/think/topics/structured-query-language
Kubernetes https://kubernetes.io/
YAML https://yaml.org/
Nomad Workload Orchestrator https://developer.hashicorp.com/nomad
Flutter https://flutter.dev/
Commanded https://hexdocs.pm/commanded/Commanded.html
Go Programming Language https://go.dev/
Clojure Programming Language https://clojure.org/
Nebulex https://hexdocs.pm/nebulex/Nebulex.html
Mnesia https://www.erlang.org/doc/apps/mnesia/mnesia.html
Cachex https://hexdocs.pm/cachex/Cachex.html
libgraph https://hexdocs.pm/libgraph/Graph.html
Horde https://hexdocs.pm/horde/Horde.Registry.html
NocFree split keyboard https://www.nocfree.com/
Micah’s LinkedIn https://www.linkedin.com/in/micah-cooper-4a737560/

The State of Security in Elixir with Holden Oullette

podcast@smartlogic.io (SmartLogic LLC) — Thu, 30 Apr 2026 06:00:00 -0400

In the Elixir Wizards season 15 premiere, host Charles Suggs is joined by Holden Oullette, Senior Security Software Engineer at Netflix and maintainer of Sobelow, to talk about how security is evolving in the Elixir ecosystem.

We discuss how certain features of the Elixir programming language (like functional patterns and server-side rendering) provide natural immunity against some common vulnerabilities, and what that means as the language continues to grow. Holden shares how tools like Sobelow are adapting and how new technologies like LLMs and Elixir's type system may help to strengthen security practices.

We cover supply chain risks, ecosystem-level responsibility and reputation management, and how initiatives like AEGIS are prepping the community for more widespread adoption. We wrap with practical tips for teams to be more security-minded throughout the software development lifecycle without slowing everything down.

Key topics discussed in this episode:

How Elixir’s design influences secure-by-default development
Security tradeoffs between server-side and client-heavy architecture
Supply chain risks and what the ecosystem is doing to prepare
Static analysis with tools like Sobelow and AST-based pattern matching
Where LLMs fit into modern security workflows
The role of Elixir’s upcoming type system in improving tooling
Securing CI/CD pipelines and production environments
Balancing development speed with security requirements
Dependency management and vulnerability monitoring
The AEGIS Initiative and ecosystem-wide security efforts

Links mentioned:

Holden’s GitHub https://github.com/houllette
Elixir Programming Language https://elixir-lang.org/
Security-focused static analysis for the Phoenix Framework https://github.com/nccgroup/sobelow
Code Security for Builders https://semgrep.dev/
Erlang Ecosystems Foundation https://erlef.org/
Phoenix Framework https://www.phoenixframework.org/
WebSockets https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.Socket.html
https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API
Open Worldwide Application Security Project https://owasp.org/
https://github.com/elixir-ecto/ecto
Log4j Vulnerability https://www.ncsc.gov.uk/information/log4j-vulnerability-what-everyone-needs-to-know
React2Shell Vulnerability https://www.finra.org/guidance/guidance/cybersecurity-advisory-react2shell
The Heartbleed Bug https://www.heartbleed.com/
Elixir Type System https://hexdocs.pm/elixir/main/gradual-set-theoretic-types.html
Holden Oullette “Securing the Future: A Roadmap to Making Elixir the Safest Language” ElixirConf 2024 https://youtu.be/gpvKxS6sY8Y
Aegis Initiative: Supply Chain Security & Compliance Initiative https://security.erlef.org/aegis/
OIDC Tokens https://openid.net/
Anthropic’s Claude Mythos & Cybersecurity https://red.anthropic.com/2026/mythos-preview/
Igniter Code Generation Framework https://github.com/ash-project/igniter
https://smartlogic.io/podcast/elixir-wizards/s13-e01-igniter-code-generation-zach-daniel/
Secure-by-default open source software https://www.chainguard.dev/
https://www.docker.com/
https://github.com/dependabot
https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-models.html
https://nixos.org/
https://smartlogic.io/podcast/elixir-wizards/s14-e08-nix-for-elixir-apps/
https://fedoraproject.org/
https://kubernetes.io/
https://netflix.github.io/chaosmonkey/
https://netflixtechblog.com/all?topic=chaos-monkey

Special Guest: Holden Oullette.

Enter the Elixirverse: Season 14 Wrap-Up

podcast@smartlogic.io (SmartLogic LLC) — Thu, 28 Aug 2025 06:30:00 -0400

Today, the Elixir Wizards wrap up Season 14 “Enter the Elixirverse.” Dan, Charles, and Sundi look back at some common themes: Elixir plays well with others, bridges easily to access languages and tools, and remains a powerful technology for data flow, concurrency, and developer experience. We revisit the popular topics of the year, from types and tooling to AI orchestration and reproducible dev environments, and share what we’re excited to explore next.

We also invite your questions and takeaways to help shape future seasons and conference conversations. Season 14 doubles as a handy primer for anyone curious about how Elixir integrates across the stack.

Key topics discussed in this episode:

Lessons from a season of interoperability
Set-theoretic types and what new compiler warnings unlock
AI in practice: LLM orchestration, fallbacks, and real-world use
SDUI and GraphQL patterns for shipping UI across web/iOS/Android
Dataframes in Elixir with Explorer for analytics workflows
Python interoperability (ErlPort, PythonX) and when to reach for it
Reproducible dev environments with Nix and friends
Performance paths: Rustler and Zig for native extensions
Bluetooth & Nerves: Blue Heron and hardware integrations
DevEx upgrades: LiveView, build pipelines, and standard project setup
Observability and ops: Prometheus/Grafana and sensible deployments
Community feedback, conferences, and what’s on deck for next season ### Links mentioned in this episode:

Cars.com
S14E06 SDUI at Scale with Elixir https://youtu.be/nloRcgngT_k?si=g4Zd4N1s56Ronrtw
https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
https://wordpress.com/
https://elixir-lang.org/
S14E01 Zigler: Zig NIFs for Elixir https://youtu.be/hSAvWxh26TU?si=d5_5tVuZbNw0KCfT
https://ziglang.org/
https://hexdocs.pm/zigler/Zig.html
https://github.com/blue-heron/blue_heron
https://github.com/elixir-explorer/explorer
S14E08 Nix for Elixir Apps https://youtu.be/yymUcgy4OAk?si=BRgTlc2VK5bsIhIf
https://nixos.org/
https://nix.dev/
S14E07 Set Theoretic Types in Elixir https://youtu.be/qMmEnXcHxL4?si=Ux2lebiwEp3mc_0e
S14E10 Python in Elixir Apps https://youtu.be/SpVLrrWkRqE?si=ld3oQVXVlWHpo7eV
https://www.python.org/
https://hexdocs.pm/pythonx/
https://github.com/Pyrlang/Pyrlang
https://github.com/erlport/erlport
S14E03 LangChain: LLM Integration for Elixir https://youtu.be/OwFaljL3Ptc?si=A0sDs2dzJ0UoE2PY
https://github.com/brainlid/langchain
S14E04 Nx & Machine Learning in Elixir https://youtu.be/Ju64kAMLlkw?si=zdVnkBTTLHvIZNBm
S14E05 Rustler: Bridging Elixir and Rust https://youtu.be/2RBw7B9OfwE?si=aRVYOyxxW8fTmoRA
https://github.com/rusterlium/rustler
Season 3: Working with Elixir https://youtube.com/playlist?list=PLTDLmInI9YaDbhMRpGuYpboVNbp1Fl9PD&si=hbe7qt4gRUfrMtpj
S14E11 Vibe Coding the LoopedIn Crochet App https://youtu.be/DX0SjmPE92g?si=zCBPjS1huRDIeVeP
Season 5: Adopting Elixir
YouTubeLaunchisode and Outlaws Takeover with Chris Keathley, Amos King, and Anna Neyzberg
S13E01 Igniter: Elixir Code Generation https://youtu.be/WM9iQlQSF_g?si=e0CAiML2qC2SxmdL
Season 8: Elixir in a Polyglot Environment https://youtube.com/playlist?list=PLTDLmInI9YaAPlvMd-RDp6LWFjI67wOGN&si=YCI7WLA8qozD57iw

!! We Want to Hear Your Thoughts *!!*

Have questions, comments, or topics you'd like us to discuss on the podcast?

Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9

Elixir DevOps & Interoperability with Dan Ivovich and Charles Suggs

podcast@smartlogic.io (SmartLogic LLC) — Thu, 14 Aug 2025 06:30:00 -0400

In this episode of Elixir Wizards, host Sundi Myint chats with SmartLogic engineers and fellow Wizards Dan Ivovich and Charles Suggs about the practical tooling that surrounds Elixir in a consultancy setting. We dig into how standardized dev environments, sensible scaffolding, and clear observability help teams ship quickly across many client projects without turning every app into a snowflake. Join us for a grounded tour of what’s working for us today (and what we’ve retired), plus how we evaluate new tech (including AI) through a pragmatic, Elixir-first lens.

Key topics discussed in this episode:

Standardizing across projects: why consistent environments matter in consultancy work
Nix (and flakes) for reproducible dev setups and faster onboarding
Igniter to scaffold common patterns (auth, config, workflows) without boilerplate drift
Deployment approaches: OTP releases, runtime config, and Ansible playbooks
Frontend pipeline evolution: from Brunch/Webpack to esbuild + Tailwind
Observability in practice: Prometheus metrics and Grafana dashboards
Handling time-series and sensor data
When Explorer can be the database
Picking the right tool: Elixir where it shines, integrations where it counts
Using AI with intention: code exploration, prototypes, and guardrails for IP/security
Keeping quality high across multiple codebases: tests, telemetry, and sensible conventions
Reducing context-switching costs with shared patterns and playbooks

Links mentioned:

http://smartlogic.io
https://nix.dev/
https://github.com/ash-project/igniter
Elixir Wizards S13E01 Igniter with Zach Daniel https://youtu.be/WM9iQlQSF_g
https://github.com/elixir-explorer/explorer
Elixir Wizards S14E09 Explorer with Chris Grainger https://youtu.be/OqJDsCF0El0
Elixir Wizards S14E08 Nix with Norbert (Nobbz) Melzer https://youtu.be/yymUcgy4OAk
https://jqlang.org/
https://github.com/BurntSushi/ripgrep
https://github.com/resources/articles/devops/ci-cd
https://prometheus.io/
https://capistranorb.com/
https://ansible.com/
https://hexdocs.pm/phoenix/releases.html
https://brunch.io/
https://webpack.js.org/loaders/css-loader/
https://tailwindcss.com/
https://sass-lang.com/dart-sass/
https://grafana.com/
https://pragprog.com/titles/passweather/build-a-weather-station-with-elixir-and-nerves/
https://www.datadoghq.com/
https://sqlite.org/
Elixir Wizards S14E06 SDUI at Cars.com with Zack Kayser https://youtu.be/nloRcgngT_k
https://github.com/features/copilot
https://openai.com/codex/
https://www.anthropic.com/claude-code
YouTube Video: Vibe Coding TEDCO's RFP https://youtu.be/i1ncgXZJHZs
Blog: https://smartlogic.io/blog/how-i-used-ai-to-vibe-code-a-website-called-for-in-tedco-rfp/
Blog: https://smartlogic.io/blog/from-vibe-to-viable-turning-ai-built-prototypes-into-market-ready-mvps/
https://www.thriftbooks.com/w/eragon-by-christopher-paolini/246801
https://tidewave.ai/

!! We Want to Hear Your Thoughts *!!*

Have questions, comments, or topics you'd like us to discuss in our season recap episode?

Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9

Vibe Coding the LoopedIn Crochet App with Kimberly Erni & Pei Pei Wang

podcast@smartlogic.io (SmartLogic LLC) — Thu, 07 Aug 2025 06:30:00 -0400

Today, co-founders Kimberly Erni and Pei Pei Wang join the Elixir Wizards to discuss their crochet app, LoopedIn. Recognizing a gap in the market for a more user-friendly and interactive crochet pattern experience, they're building an app that makes following patterns easier and more enjoyable for crocheters of all skill levels.

They're building features such as step-by-step guidance, video tutorials, and the ability to upload and convert PDF patterns into an interactive format. Kimberly explains how she's leveraging AI tools to vibe code in Elixir and LiveView.

They highlight the challenges and successes they encountered while creating a Progressive Web App (PWA) that integrates AI-powered features. They also discuss their user research and testing process, which involved gathering feedback from the crochet community to prioritize features and improve the app's UX.

Kimberly and Pei Pei share their thoughts on the potential of AI in the tech industry and how it has assisted them in the development and iteration process. They emphasize the importance of understanding the code generated by AI and the need for proper testing and verification. They offer advice to others looking to create passion projects, stressing the value of finding a partner with complementary skills and shared enthusiasm for the project.

Topics discussed in this episode:

Discovering a niche: why crochet patterns need a digital makeover
Core LoopedIn features: interactive steps, video help, PDF conversion
Building a PWA with Elixir & Phoenix LiveView for cross-platform reach
Offline support and caching strategies for on-the-go crafting
AI-driven pattern parsing: benefits and pitfalls of generated code
User research: gathering feedback from beginner to expert crocheters
Agile iterations: testing, prioritizing features, and shipping quickly
Balancing “vibe coding” with quality assurance and proper test coverage
Partnership dynamics: complementary skills and shared passion
Monetization approaches for a niche, community-driven app
Roadmap highlights: expanded social features, advanced AI tooling, and more
Lessons learned: documentation gaps, performance tuning, and UX trade-offs
Advice for side projects: start small, validate with users, and iterate

Links mentioned:

Amigurumis
https://www.amigurumi.com/
https://pragmaticstudio.com/phoenix-liveview
https://grox.io/about-product/liveview
Creating a Local First LiveView App https://www.youtube.com/watch?v=kcafwf14SDo
https://capacitorjs.com/docs
https://flutter.dev/
https://passion.place/
https://cursor.com/
https://claude.ai/
https://nerves-project.org/
https://crochetapp.web.app/
https://www.figma.com/
Little Red Book App https://www.xiaohongshu.com/

!! Try the LoopedIn app here 👉 https://looped-in.gigalixirapp.com *!!*

Add it to your phone like an app:

Open the link in Safari
Tap the Share button (square with arrow)
Tap Add to Home Screen
Tap Add

Then you can open it like a regular app! 🎉 Leave a comment if you try it!

!! We Want to Hear Your Thoughts *!!*

Have questions, comments, or topics you'd like us to discuss in our season recap episode?

Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9

Python in Elixir Apps with Victor Björklund

podcast@smartlogic.io (SmartLogic LLC) — Thu, 31 Jul 2025 06:30:00 -0400

In this episode, Elixir Wizard Charles Suggs sits down with Victor Björklund to map out the landscape of Python integration in Elixir applications. From HTTP APIs and external services to embedded runtimes like ErlPort, PythonX, and the Venomous library, we evaluate each approach’s impact on performance, coupling, and developer experience. Victor draws on real-world examples like Scrapy-based web scraping and the Swedish BankID authentication to illustrate best practices for error handling, process pooling, and effective telemetry across the BEAM boundary.

We also tackle the practical side of deployment: packaging Python dependencies in Mix releases, mocking Python calls in tests, and deploying multi-language apps with confidence. Wrapping up, Victor shares his wishlist for even tighter interop (think multiple Python interpreter instances per VM) and offers low-risk entry points, like automating monthly reports, for teams ready to explore the power of Python’s ecosystem within Elixir.

Key topics discussed in this episode:

Integration methods: HTTP APIs, ports, ErlPort, PythonX, Venomous
Performance vs. coupling trade-offs across interop patterns
Managing the Global Interpreter Lock (GIL) with process pools
Leveraging mature Python libraries (Scrapy, BankID, etc.)
Error handling strategies across BEAM↔Python boundaries
Testing mixed-language systems: mocks and integration tests
Packaging and deploying Python alongside Elixir releases
Monitoring and telemetry for multi-language pipelines
Functional programming advantages in Elixir workflows
Tool selection guidance by project requirements
Future possibilities: multiple Python interpreters in one VM
Community resources for Python–Elixir interop help

Links mentioned:

jawdropping.io
https://cplusplus.com/
https://www.python.org/
https://react.dev/
https://nodejs.org/en
https://erlport.org/
https://hexdocs.pm/pythonx/Pythonx.html
https://pyrlang.github.io/Pyrlang/
Python GIL (Global Interpreter Lock): https://realpython.com/python-gil/
https://github.com/devinus/poolboy
https://hexdocs.pm/venomous/Venomous.html
Try-catch https://syntaxdb.com/ref/python/try-catch
https://www.scrapy.org/
https://www.bankid.com/en/
https://www.phoenixframework.org/
https://www.tzeyiing.com/posts/using-a-hunky-poolboy-to-manage-your-python-erlport-processes-in-elixir/
https://medium.com/stuart-engineering/how-we-use-python-within-elixir-486eb4d266f9
https://x.com/bjorklundvictor
https://victorbjorklund.com/
https://www.linkedin.com/in/victorbjorklund/
hello@victorbjorklund.com

Explorer: Data Frames in Elixir with Chris Grainger

podcast@smartlogic.io (SmartLogic LLC) — Thu, 24 Jul 2025 06:30:00 -0400

In this episode of Elixir Wizards, Charles Suggs sits down with Chris Grainger, co-founder and CTO of Amplified and creator of the Explorer library. Chris explains how Explorer brings the familiar data-frame workflows of R’s dplyr and Python’s pandas into the Elixir world. We explore (pun intended!) how Explorer integrates with Ecto, Nx, and LiveView to build end-to-end data pipelines without leaving the BEAM, and how features like lazy evaluation and distributed frames let you tackle large datasets.

Whether you’re generating reports or driving interactive charts in LiveView, Explorer makes tabular data accessible to every Elixir developer. We wrap up by looking ahead to SQL-style backends, ADBC connectivity, and other features on the Explorer roadmap.

Key topics discussed in this episode:

dplyr- and pandas-inspired data manipulation in Elixir
Polars integration via Rust NIFs for blazing performance
Immutable data frames and BEAM-friendly concurrency
Lazy evaluation to work with arbitrarily large tables
Distributed data-frame support for multi-node processing
Seamless integration with Ecto schemas and queries
Zero-copy interoperability between Explorer and Nx tensors
Apache Arrow and ADBC protocols for cross-language I/O
Exploring SQL-style backends for remote query execution
Building interactive dashboards and charts in LiveView
Consolidating ETL workflows into a single Elixir API
Streaming data pipelines for memory-efficient processing
Tidy data principles and behavior-based API design
Real-world use cases: report generation, patent analysis, and more
Future roadmap: new backends, query optimizations, and community plugins

Links mentioned:

https://hexdocs.pm/explorer/Explorer.html
https://www.amplified.ai/
https://www.r-project.org/
https://vita.had.co.nz/papers/tidy-data.pdf
https://www.tidyverse.org/
https://www.python.org/
https://dplyr.tidyverse.org/
https://go.dev/
https://hexdocs.pm/nx/Nx.html
https://github.com/pola-rs/polars
https://github.com/rusterlium/rustler
https://www.rust-lang.org/
https://www.postgresql.org/
https://hexdocs.pm/ecto/Ecto.html
https://www.elastic.co/elasticsearch
https://arrow.apache.org/
Chris Grainger & Chris McCord Keynote ElixirConf 2024: https://youtu.be/4qoHPh0obv0
https://dbplyr.tidyverse.org/
https://spark.posit.co/
https://hexdocs.pm/pythonx/Pythonx.html
https://hexdocs.pm/vega_lite/VegaLite.html
10 Minutes to Explorer: https://hexdocs.pm/explorer/exploring_explorer.html
https://github.com/elixir-nx/scholar
https://scikit-learn.org/stable/
https://github.com/cigrainger
https://erlef.org/slack-invite/erlef
https://bsky.app/profile/cigrainger.bsky.social
https://github.com/cigrainger

Nix for Elixir Apps with Norbert (NobbZ) Melzer

podcast@smartlogic.io (SmartLogic LLC) — Thu, 17 Jul 2025 06:30:00 -0400

In this episode of Elixir Wizards, Dan Ivovich and Charles Suggs sit down with Norbert “NobbZ” Melzer to discuss how Nix enables reproducible builds, consistent development environments, and reliable deployments for Elixir projects.

Norbert shares his journey from Ruby to Elixir, contrasts Nix with NixOS, and walks us through flakes, nix-shell workflows, sandboxed builds, and rollback capabilities. Along the way, we cover real-world tips for managing Hex authentication, integrating Nix into CI/CD, wrapping Mix releases in Docker, and avoiding common pitfalls, such as flake performance traps.

Whether you’re spinning up your first dev shell or rolling out a production release on NixOS, you’ll come away with a clear, gradual adoption path and pointers to the community mentors and resources that can help you succeed.

Key topics discussed in this episode:

Reproducible, sandboxed builds vs. traditional package managers
Nix flakes for locked dependency graphs and version pinning
nix-shell: creating consistent development environments across teams
Rollback and immutable deployment strategies with Nix/NixOS
Integrating Nix with the Elixir toolchain: Hex, Mix, and CI/CD pipelines
Flakes vs. standard shells: when and how to transition
Handling private Hex repositories and authentication in Nix
Cross-platform support (macOS/Darwin, Linux variants)
Channels, overlays, and overrides for customizing builds
Dockerizing Elixir releases using Nix-based images
Home Manager for personal environment configuration
Security patching workflows in a Nix-managed infrastructure
Common pitfalls: flake performance, sandbox workarounds, and symlink behavior
Community resources and the importance of human mentorship

Links mentioned:

https://jobrad-loop.com/
https://nixos.org/
https://nix.dev/
https://nix.dev/manual/nix/2.18/command-ref/nix-shell
https://github.com/nix-darwin/nix-darwin
https://asdf-vm.com/
https://go.dev/
https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/packaging_and_distributing_software/introduction-to-rpm_packaging-and-distributing-software
Nix Flake templates for Elixir https://github.com/jurraca/elixir-templates
https://www.docker.com/
https://www.sudo.ws/
https://ubuntu.com/
https://archlinux.org/
Nobbz’s blog https://blog.nobbz.dev/blog/
https://ayats.org/blog/nix-workflow
@nobbz.dev on BlueSky
@NobbZ1981 on Twitter
https://www.linkedin.com/in/norbert-melzer/
https://youtu.be/HbtbdLolHeM?si=6M7fulTQZmuWGGCM (talk on CodeBEAM)

Set Theoretic Types in Elixir with José Valim

podcast@smartlogic.io (SmartLogic LLC) — Thu, 10 Jul 2025 06:30:00 -0400

Elixir creator José Valim returns to the podcast to unpack the latest developments in Elixir’s set-theoretic type system and how it is slotting into existing code without requiring annotations. We discuss familiar compiler warnings, new warnings based on inferred types, a phased rollout in v1.19/v1.20 that preserves backward compatibility, performance profiling the type checks across large codebases, and precise typing for maps as both records and dictionaries.

José also touches on CNRS academic collaborations, upcoming LSP/tooling enhancements, and future possibilities like optional annotations and guard-clause typing, all while keeping Elixir’s dynamic, developer-friendly experience front and center.

Key topics discussed in this episode:

Set-theoretic typing (union, intersection, difference)
Compiler-driven inference with zero annotations
Phased rollout strategy in 1.19 and 1.20
Performance profiling for large codebases
Map typing as records and dictionaries
Exhaustivity checks and behavioral typing in GenServers
Language Server Protocol & tooling updates
Future optional annotations and guard-clause typing
CNRS collaboration for theoretical foundations
Clear error messages and false-positive reduction
Community-driven feedback and iterative improvements

Links mentioned:

https://github.com/elixir-nx
https://livebook.dev/
https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
https://hexdocs.pm/elixir/main/gradual-set-theoretic-types.html
https://hexdocs.pm/dialyxir/0.4.0/readme.html
https://remote.com/
Draw the Owl meme: https://i.imgur.com/rCr9A.png
https://dashbit.co/blog/data-evolution-with-set-theoretic-types
https://hexdocs.pm/ecto/Ecto.html
https://github.com/elixir-lsp/elixir-ls

Special Guest: José Valim.

SDUI at Scale: GraphQL & Elixir at Cars.com with Zack Kayser

podcast@smartlogic.io (SmartLogic LLC) — Thu, 03 Jul 2025 06:30:00 -0400

Zack Kayser, Staff Software Engineer at cars.com, joins Elixir Wizards Sundi Myint and Charles Suggs to discuss how Cars.com adopted a server-driven UI (SDUI) architecture powered by Elixir and GraphQL to deliver consistent, updatable interfaces across web, iOS, and Android.

We explore why SDUI matters for feature velocity, how a mature design system and schema planning make it feasible, and what it takes, culturally and technically, to move UI logic from client code into a unified backend.

Key topics discussed in this episode:

SDUI fundamentals and how it differs from traditional server-side rendering
GraphQL as the single source of truth for UI components and layouts
Defining abstract UI components on the server to eliminate duplicate logic
Leveraging a robust design system as the foundation for SDUI success
API-first development and cross-team coordination for schema changes
Mock data strategies for early UI feedback without breaking clients
Handling breaking changes and hot-fix deployments via server-side updates
Enabling flexible layouts and A/B testing through server-controlled ordering
Balancing server-driven vs. client-managed UI
Iterative SDUI rollout versus “big-bang” migrations in large codebases
Using type specs and Dialyxir for clear cross-team communication
Integration testing at the GraphQL layer to catch UI regressions early
Quality engineering’s role in validating server-driven interfaces
Production rollback strategies across web and native platforms
Considerations for greenfield projects adopting SDUI from day one
Zack and Ethan's upcoming Instrumenting Elixir Apps book

Links mentioned:

https://cars.com
https://github.com/absinthe-graphql/absinthe
Telemetry & Observability for Elixir Apps Ep: https://youtu.be/1V2xEPqqCso
https://www.phoenixframework.org/blog/phoenix-liveview-1.0-released
https://hexdocs.pm/phoenix_live_view/assigns-eex.html
https://graphql.org/
https://tailwindcss.com/
https://github.com/jeremyjh/dialyxir
https://github.com/rrrene/credo
GraphQL Schema https://graphql.org/learn/schema/
SwiftUI https://developer.apple.com/documentation/swiftui/
Kotlin https://kotlinlang.org/
https://medium.com/airbnb-engineering/a-deep-dive-into-airbnbs-server-driven-ui-system-842244c5f5
Zack’s Twitter: https://x.com/kayserzl/
Zack’s LinkedIn: https://www.linkedin.com/in/zack-kayser-93b96b88

Special Guest: Zack Kayser.

Rustler: Bridging Elixir and Rust with Sonny Scroggin

podcast@smartlogic.io (SmartLogic LLC) — Thu, 26 Jun 2025 06:30:00 -0400

Rustler Core Team Member Sonny Scroggin joins Elixir Wizards Sundi Myint and Charles Suggs. Rustler serves as a bridge to write Native Implemented Functions (NIFs) in Rust that can be called from Elixir code. This combo leverages Rust's performance and memory safety while maintaining Elixir's fault tolerance and concurrency model, creating a powerful solution for CPU-intensive operations within Elixir applications.

Sonny provides guidance on when developers should consider using NIFs versus other approaches like ports or external services and highlights the considerations needed when stepping outside Elixir's standard execution model into native code.

Looking toward the future, Sonny discusses exciting developments for Rustler, including an improved asynchronous NIF interface, API modernization efforts, and better tooling. While Rust offers tremendous performance benefits for specific use cases, Sonny emphasizes that Elixir's dynamic nature and the BEAM's capabilities for distributed systems remain unmatched for many applications. Rustler simply provides another powerful tool that expands what developers can accomplish within the Elixir ecosystem.

Key topics discussed in this episode:

Rust as a "high-level low-level language" with memory safety
NIFs (Native Implemented Functions) in the BEAM virtual machine
Rustler's role simplifying Rust-Elixir integration with macros
CPU-intensive operations as primary NIF use cases
Beam scheduler interaction considerations with native code
Dirty schedulers for longer-running NIFs in OTP 20+
Memory safety advantages of Rust for NIFs
Development workflow using Mix tasks for Rustler
Common pitfalls when first working with Rust
Error handling improvements possible with Rustler NIFs
Differences between ports, NIFs, and external services
Asynchronous programming approaches in Rust versus Elixir
Tokyo runtime integration for asynchronous operations
Static NIFs for mobile device compatibility
Upcoming CLI tooling to simplify Rustler development
Rustler's API modernization efforts for better ergonomics
Thread pool sharing across multiple NIFs
Wasm integration possibilities for the BEAM
Compile-time safety versus dynamic runtime capabilities
Performance considerations when implementing NIFs
Compiler-assisted memory management in Rust
Automatic encoding/decoding between Rust and Elixir types
The importance of proper error handling
Real-world application in high-traffic authentication servers
Community resources for learning Rustler

Links mentioned:

https://github.com/rusterlium/rustler
https://github.com/rust-lang/rust
https://www.angelfire.lycos.com/
https://www.webdesignmuseum.org/flash-websites
https://www.php.net/
https://xmpp.org/
https://jabberd2.org/
Geocities: https://cybercultural.com/p/geocities-1995/ (fun fact: when you search Geocities on Google, the results page is in Comic Sans font.)
https://bleacherreport.com/
https://hexdocs.pm/jose/readme.html
https://github.com/rust-lang/rust-bindgen
Erlang Ports: https://www.erlang.org/doc/system/c_port.html
Erlang ETFs (External Term Format): https://www.erlang.org/doc/apps/erts/erl_ext_dist.html
Elixir gRPC https://github.com/elixir-grpc/grpc
gRPC (“Remote Proceduce Call”): https://grpc.io/
dirty_cpu.ex https://github.com/E-xyza/zigler/blob/main/lib/zig/nif/dirty_cpu.ex
ets https://www.erlang.org/doc/apps/stdlib/ets.html
Mnesia https://www.erlang.org/doc/apps/mnesia/mnesia.html
VPPs (Virtual Power Plants): https://www.energy.gov/lpo/virtual-power-plants
https://nixos.org/
WASM WebAssembly with Elixir: https://github.com/RoyalIcing/Orb
Rust Tokio https://tokio.rs/

Getting Started:
https://hexdocs.pm/rustler/0.17.0/Mix.Tasks.Rustler.New.html
https://rustup.rs/

Special Guest: Sonny Scroggin.

Nx and Machine Learning in Elixir with Sean Moriarity

podcast@smartlogic.io (SmartLogic LLC) — Thu, 19 Jun 2025 06:30:00 -0400

Today on Elixir Wizards, hosts Sundi Myint and Charles Suggs catch up with Sean Moriarity, co-creator of the Nx project and author of Machine Learning in Elixir. Sean reflects on his transition from the military to a civilian job building large language models (LLMs) for software. He explains how the Elixir ML landscape has evolved since the rise of ChatGPT, shifting from building native model implementations toward orchestrating best-in-class tools.

We discuss the pragmatics of adding ML to Elixir apps: when to start with out-of-the-box LLMs vs. rolling your own, how to hook into Python-based libraries, and how to tap Elixir’s distributed computing for scalable workloads. Sean closes with advice for developers embarking on Elixir ML projects, from picking motivating use cases to experimenting with domain-specific languages for AI-driven workflows.

Key topics discussed in this episode:

The evolution of the Nx (Numerical Elixir) project and what's new with ML in Elixir
Treating Elixir as an orchestration layer for external ML tools
When to rely on off-the-shelf LLMs vs. custom models
Strategies for integrating Elixir with Python-based ML libraries
Leveraging Elixir’s distributed computing strengths for ML tasks
Starting ML projects with existing data considerations
Synthetic data generation using large language models
Exploring DSLs to streamline AI-powered business logic
Balancing custom frameworks and service-based approaches in production
Pragmatic advice for getting started with ML in Elixir

Links mentioned:

https://hexdocs.pm/nx/intro-to-nx.html
https://pragprog.com/titles/smelixir/machine-learning-in-elixir/
https://magic.dev/
https://smartlogic.io/podcast/elixir-wizards/s10-e10-sean-moriarity-machine-learning-elixir/
Pragmatic Bookshelf: https://pragprog.com/
ONNX Runtime Bindings for Elixir: https://github.com/elixir-nx/ortex
https://github.com/elixir-nx/bumblebee
Silero Voice Activity Detector: https://github.com/snakers4/silero-vad
Paulo Valente Graph Splitting Article: https://dockyard.com/blog/2024/11/06/2024/nx-sharding-update-part-1
Thomas Millar's Twitter https://x.com/thmsmlr
https://github.com/thmsmlr/instructor_ex
https://phoenix.new/
https://tidewave.ai/
https://en.wikipedia.org/wiki/BERT_(language_model)
Talk: PyTorch: Fast Differentiable Dynamic Graphs in Python by Soumith Chintala
https://hexdocs.pm/axon/Axon.html
https://hexdocs.pm/exla/EXLA.html
VLM (Vision Language Models Explained): https://huggingface.co/blog/vlms
https://github.com/ggml-org/llama.cpp
Vector Search in Elixir: https://github.com/elixir-nx/hnswlib
https://www.amplified.ai/
Llama 4 https://mistral.ai/

Mistral Open-Source LLMs: https://mistral.ai/
https://github.com/openai/whisper
Elixir Wizards Season 5: Adopting Elixir https://smartlogic.io/podcast/elixir-wizards/season-five
https://docs.ray.io/en/latest/ray-overview/index.html
https://hexdocs.pm/flame/FLAME.html
https://firecracker-microvm.github.io/
https://fly.io/
https://kubernetes.io/
WireGuard VPNs https://www.wireguard.com/
https://hexdocs.pm/phoenixpubsub/Phoenix.PubSub.html
https://www.manning.com/books/deep-learning-with-python
Code BEAM 2025 Keynote: Designing LLM Native Systems - Sean Moriarity
Ash Framework https://ash-hq.org/
Sean’s Twitter: https://x.com/seanmoriarity
Sean’s Personal Blog: https://seanmoriarity.com/

Erlang Ecosystems Foundation Slack: https://erlef.org/slack-invite/erlef
Elixir Forum https://elixirforum.com/
Sean’s LinkedIn: https://www.linkedin.com/in/sean-m-ba231a149/

Special Guest: Sean Moriarity.

LangChain: LLM Integration for Elixir Apps with Mark Ericksen

podcast@smartlogic.io (SmartLogic LLC) — Thu, 12 Jun 2025 06:30:00 -0400

Mark Ericksen, creator of the Elixir LangChain framework, joins the Elixir Wizards to talk about LLM integration in Elixir apps. He explains how LangChain abstracts away the quirks of different AI providers (OpenAI, Anthropic’s Claude, Google’s Gemini) so you can work with any LLM in one more consistent API. We dig into core features like conversation chaining, tool execution, automatic retries, and production-grade fallback strategies.

Mark shares his experiences maintaining LangChain in a fast-moving AI world: how it shields developers from API drift, manages token budgets, and handles rate limits and outages. He also reveals testing tactics for non-deterministic AI outputs, configuration tips for custom authentication, and the highlights of the new v0.4 release, including “content parts” support for thinking-style models.

Key topics discussed in this episode:

• Abstracting LLM APIs behind a unified Elixir interface
• Building and managing conversation chains across multiple models
• Exposing application functionality to LLMs through tool integrations
• Automatic retries and fallback chains for production resilience
• Supporting a variety of LLM providers
• Tracking and optimizing token usage for cost control
• Configuring API keys, authentication, and provider-specific settings
• Handling rate limits and service outages with degradation
• Processing multimodal inputs (text, images) in Langchain workflows
• Extracting structured data from unstructured LLM responses
• Leveraging “content parts” in v0.4 for advanced thinking-model support
• Debugging LLM interactions using verbose logging and telemetry
• Kickstarting experiments in LiveBook notebooks and demos
• Comparing Elixir LangChain to the original Python implementation
• Crafting human-in-the-loop workflows for interactive AI features
• Integrating Langchain with the Ash framework for chat-driven interfaces
• Contributing to open-source LLM adapters and staying ahead of API changes
• Building fallback chains (e.g., OpenAI → Azure) for seamless continuity
• Embedding business logic decisions directly into AI-powered tools
• Summarization techniques for token efficiency in ongoing conversations
• Batch processing tactics to leverage lower-cost API rate tiers
• Real-world lessons on maintaining uptime amid LLM service disruptions

Links mentioned:
https://rubyonrails.org/
https://fly.io/
https://zionnationalpark.com/
https://podcast.thinkingelixir.com/
https://github.com/brainlid/langchain
https://openai.com/
https://claude.ai/
https://gemini.google.com/
https://www.anthropic.com/
Vertex AI Studio https://cloud.google.com/generative-ai-studio
https://www.perplexity.ai/
https://azure.microsoft.com/
https://hexdocs.pm/ecto/Ecto.html
https://oban.pro/
Chris McCord’s ElixirConf EU 2025 Talk https://www.youtube.com/watch?v=ojL_VHc4gLk

Getting started:
https://hexdocs.pm/langchain/getting_started.html
https://ash-hq.org/
https://hex.pm/packages/langchain
https://hexdocs.pm/igniter/readme.html
https://www.youtube.com/watch?v=WM9iQlQSF_g
@brainlid on Twitter and BlueSky

Special Guest: Mark Ericksen.

Blue Heron: Bluetooth Low Energy (BLE) for Elixir & Nerves with Connor Rigby

podcast@smartlogic.io (SmartLogic LLC) — Thu, 05 Jun 2025 06:30:00 -0400

Connor Rigby joins the Elixir Wizards to talk about Blue Heron BLE (Bluetooth Low Energy) support for Elixir apps. Blue Heron implements the BLE specs in pure Elixir, leveraging binary pattern matching and concurrent message processing to handle Bluetooth protocols. Unlike most solutions that require C ports or NIFs, Blue Heron runs entirely in user space, so it works seamlessly in both Nerves-based embedded projects and (eventually) desktop Elixir applications.

We discuss how Nerves development differs from building Phoenix apps. Connor shares challenges he's experienced with hardware compatibility, where some chips only partially implement the spec, and he discusses the surprisingly deep (but sometimes incomplete) world of BLE device profiles. His tip for anyone entering the BLE space: read the official spec instead of trusting secondhand blog posts. Tools like Nerves LiveBook give you hands-on examples, so you can get a BLE prototype running on a Raspberry Pi and your phone in no time.

Key topics discussed in this episode:

Blue Heron origins and “bird” naming convention
BLE vs. Bluetooth Classic: core differences
Pure Elixir implementation—no C dependencies
Binary pattern matching for packet parsing
Hardware transport options: UART, SPI, USB, SDIO
GenServer patterns in Nerves vs. Phoenix
Linux requirement and power-consumption trade-offs
GATT (Generic Attribute Table) implementation patterns
SQLite integration for Nerves apps
Hardware chip quirks and spec compliance
Manufacturer-specific commands and workarounds
BLE device profiles and spec gaps
Security Management Profile (SMP) for encryption
Device connection and pairing workflows
Web vs. embedded development differences
Where to get started: hardware recommendations and docs

Links mentioned:

https://github.com/ConnorRigby/
https://github.com/blue-heron/
https://nerves-project.org/
BLE (Bluetooth Low Energy) https://en.wikipedia.org/wiki/Bluetooth_Low_Energy
https://developer.apple.com/ibeacon/

https://learnyousomeerlang.com/building-otp-applications
Linux https://www.linux.org/
HCI (Host Controller Interface) https://en.wikipedia.org/wiki/Host_controller_interface
Circuits UART Library https://hexdocs.pm/circuits_uart/readme.html
SPI (Serial Peripheral Interface) https://github.com/elixir-circuits/circuits_spi
SDIO (Secure Digital Input Output https://en.wikipedia.org/wiki/SDIO
Raspberry Pi https://www.raspberrypi.com/
Coral SoM Dev Board https://coral.ai/products/dev-board/
BeagleBone Single-Board Linux Computer https://www.beagleboard.org/boards/beaglebone-black
https://www.bluetooth.com/bluetooth-resources/intro-to-bluetooth-gap-gatt/
Genservers https://hexdocs.pm/elixir/1.12/GenServer.html
https://hexdocs.pm/ecto/Ecto.html
https://github.com/elixir-sqlite/ecto_sqlite3
https://github.com/nerves-livebook/nerves_livebook

Special Guest: Connor Rigby.

Zigler: Zig NIFs for Elixir with Isaac Yonemoto

podcast@smartlogic.io (SmartLogic LLC) — Thu, 29 May 2025 06:00:00 -0400

In the Season 14 premiere, hosts Dan Ivovich and Sundi Myint chat with Isaac Yonemoto, creator of the Zigler library, to explore how Zigler brings Zig’s performance and safety to Elixir through Native Implemented Functions (NIFs). Isaac walks through the core design of Zigler and how it auto-generates the Elixir-to-Zig bridge, enforces type safety, and exposes multiple execution modes (normal, dirty, threaded). The conversation covers real-world applications, from SIMD-powered token selection for LLM hardware acceleration to OTP-style fault tolerance in low-level code.

Isaac shares his own journey: stepping back from professional software work to launch a biotech startup focused on reducing drug manufacturing costs while continuing to maintain Zigler and even leveraging Elixir for bioinformatics pipelines.

Topics discussed in this episode:

What is the Zigler library and what does it do?
What does it mean to run a "dirty NIF"?
Async mode is temporarily removed from Zig (therefore, yielding NIFs is temporarily deprecated in Zigler)
Zigler’s three execution modes (normal, dirty, and threaded) and how you switch modes with a single config change
Isaac’s journey from professional software work to launching a biotech startup
How Isaac leverages Elixir in bioinformatics pipelines at his startup
LLM hardware acceleration using Zigler NIFs and SIMD-powered token picking
Fault-tolerant load balancing of NIF workloads via OTP principles
Transparent handling and recovery from hardware failures through monitoring
Potential future memory-safety features in Zig and their implications
The Elixir-based borrow-checker prototype: purpose and design
Unit-checking for scientific computations to enforce correctness
New OS support in Zigler 0.14: macOS, Windows, and FreeBSD
Inline Zig code authoring directly within Elixir modules
Isaac's commitment to maintain Zigler through its 1.0 release (...and beyond?)

Links mentioned:

https://github.com/E-xyza/zigler
https://github.com/ziglang/zig
https://vidalalabs.com/
Zig Programming Language: https://ziglang.org/
https://obsidian.md/
https://hexdocs.pm/elixir/macros.html
https://erlang.org/documentation/doc-4.7.3/doc/extensions/macros.html
A Deep Dive Into the Elixir AST: https://dorgan.ar/posts/2021/04/the_elixir_ast/
https://www.erlang.org/doc/system/nif.html
https://nodejs.org/en
Llama Open-Source LLM: https://www.llama.com/
Mixtral Open-Source LLM: https://mistral.ai/news/mixtral-of-experts
https://Fly.io
SIMD: https://en.wikipedia.org/wiki/Single_instruction,_multiple_data
https://opentrons.com/
CI/CD: https://en.wikipedia.org/wiki/CI/CD
https://hexdocs.pm/zigler/Zig.html
http://www.x.com/DNAutics
https://bsky.app/profile/dnautics.bsky.social

Building an Open Vehicle Control System using Elixir and Nerves with Marc, Thibault, and Loïc

podcast@smartlogic.io (SmartLogic LLC) — Thu, 26 Dec 2024 06:30:00 -0500

For the Season 13 finale, Elixir Wizards Dan and Charles are joined by Spin42 Engineers Marc Lainez, Thibault Poncelet, and Loïc Vigneron to discuss their work retrofitting a 2007 VW Polo and creating an Open Vehicle Control System (OVCS). Using Elixir, Nerves, and Raspberry Pis, the team is reimagining vehicle technology to extend the lifespan of older cars and reduce waste—all while making the process approachable and open source.

The Spin42 team shares the technical details behind OVCS and how they use Elixir and Nerves to interact with the CAN bus and build a Vehicle Management System (VMS) to coordinate various vehicle components. They dive into the challenges of reverse engineering CAN messages, designing a distributed architecture with Elixir processes, and ensuring safety with fail-safe modes and emergency shutoffs.

Beyond the technical, the team discusses their motivation for the project—upgrading older vehicles with modern features to keep them on the road, building an open-source platform to share their findings with others, and above all-- to just have fun. They explore potential applications for OVCS in boats, construction equipment, and other vehicles, while reflecting on the hurdles of certifying the system for road use.

If you’ve ever wondered how Elixir and Nerves can drive innovation beyond software, this episode is packed with insights into automotive computing, hardware development, and the collaborative potential of open-source projects.

Topics Discussed in this Episode:

Retrofitting a 2007 VW Polo with electric engines and modern tech
Building an open-source Vehicle Control System (OVCS) using Elixir and Nerves
Leveraging Elixir to interact with the CAN bus and parse proprietary messages
Designing a Vehicle Management System (VMS) to coordinate vehicle components
Developing custom hardware for CAN communication
Creating a YAML-based DSL for CAN message and frame descriptions
Building a distributed architecture using Elixir processes
Ensuring safety with fail-safe modes and emergency shutoffs
Using Flutter and Nerves to build a custom infotainment system
Exploring autonomous driving features with a ROS2 bridge
Developing remote control functionality with a Mavlink transmitter
Testing OVCS features at scale with a Traxxas RC car (OVCS Mini)
Challenges of certifying OVCS for road use and meeting regulatory requirements
Encouraging community contributions to expand OVCS functionality
Balancing open-source projects with contract work to sustain development
The fun and fulfillment of experimenting with Elixir beyond traditional applications

Links mentioned:

https://www.spin42.com/
https://nerves-project.org/
Quadcopter https://github.com/Spin42/elicopter
https://github.com/linux-can/can-utils
https://docs.kernel.org/networking/can.html
https://github.com/open-vehicle-control-system/cantastic
https://github.com/commaai/opendbc
https://en.wikipedia.org/wiki/CAN_bus#CAN_FD
https://comma.ai/
https://en.wikipedia.org/wiki/CAN_FD
https://webkit.org/wpe/
https://docs.nvidia.com/jetson/archives/r35.4.1/DeveloperGuide/text/SD/WindowingSystems/WestonWayland.html
https://buildroot.org/
https://vuejs.org/
https://flutter.dev/
https://github.com/smartrent/elixir_flutter_embedder
https://www.raspberrypi.com/products/raspberry-pi-5/
The Rabbit Pickup https://www.hemmings.com/stories/value-guide-1980-83-volkswagen-pickup
https://www.expresslrs.org/software/mavlink
https://industrial-training-master.readthedocs.io/en/melodic/_source/session7/ROS1-ROS2-bridge.html
https://github.com/ros2/rcl
https://github.com/open-vehicle-control-system/traxxas
Contact Marc, Thibault, and Loïc: info@spin42.com

Special Guests: Loïc Vigneron, Marc Lainez, and Thibault Poncelet.

Creating Horizon: Deploy Elixir Phoenix Apps on FreeBSD with Jim Freeze

podcast@smartlogic.io (SmartLogic LLC) — Thu, 19 Dec 2024 06:30:00 -0500

The Elixir Wizards welcome Jim Freeze, organizer of ElixirConf and creator of the Horizon library. Jim shares his journey from organizing Ruby conferences to founding and growing ElixirConf into the community cornerstone it is today. He reflects on the challenges of running a major conference, how COVID-19 shaped the event, and why the talks remain an evergreen resource for the Elixir ecosystem.

We discuss Horizon, Jim’s deployment library for Elixir and Phoenix applications with Postgres on FreeBSD. Driven by a need for simplicity and cost-effectiveness, Jim explains how Horizon minimizes external dependencies while delivering fault-tolerant and streamlined setups. He compares it to tools like Fly, Terraform, and Ansible, highlighting its low cognitive load and flexibility—key benefits for developers seeking more control over their deployment environments.

Jim also unpacks the broader value of understanding and customizing your deployment stack rather than relying solely on managed services. He discusses the benefits of using FreeBSD, including its stability, security, and performance advantages, as well as its robust ZFS file system.

Jim emphasizes the importance of coherent deployment workflows, community collaboration, and contributions to open-source projects like Horizon. He invites listeners to explore Horizon, share feedback, and own their deployments.

Topics discussed in this episode:

Jim Freeze’s background organizing RubyConf and founding ElixirConf
Reducing reliance on managed services and external dependencies
Simplifying deployments with minimal tools and lower cognitive overhead
The trade-offs of cutting-edge tools vs. stable, well-documented solutions
The importance of customizing deployment tools to meet specific needs
Addressing challenges with Tailwind compatibility
Streamlining the FreeBSD installation process for Horizon users
Community collaboration: contributing to open-source tools
Jim’s vision for Horizon: PKI support, hot standby features, and serverless potential

Special Guest: Jim Freeze.

Telemetry & Observability for Elixir Apps at Cars.com with Zack Kayser & Ethan Gunderson

podcast@smartlogic.io (SmartLogic LLC) — Thu, 12 Dec 2024 06:30:00 -0500

Zack Kayser and Ethan Gunderson, Software Engineers at Cars Commerce, join the Elixir Wizards to share their expertise on telemetry and observability in large-scale systems. Drawing from their experience at Cars.com—a platform handling high traffic and concurrent users—they discuss the technical and organizational challenges of scaling applications, managing microservices, and implementing effective observability practices.

The conversation highlights the pivotal role observability plays in diagnosing incidents, anticipating system behavior, and asking unplanned questions of a system. Zack and Ethan explore tracing, spans, and the unique challenges introduced by LiveView deployments and WebSocket connections.

They also discuss the benefits of OpenTelemetry as a vendor-agnostic instrumentation tool, the significance of Elixir’s telemetry library, and practical steps for developers starting their observability journey. Additionally, Zack and Ethan introduce their upcoming book, Instrumenting Elixir Applications, which will offer guidance on integrating telemetry and tracing into Elixir projects.

Topics Discussed:

Cars.com’s transition to Elixir and scaling solutions
The role of observability in large-scale systems
Uncovering insights by asking unplanned system questions
Managing high-traffic and concurrent users with Elixir
Diagnosing incidents and preventing recurrence using telemetry
Balancing data collection with storage constraints
Sampling strategies for large data volumes
Tracing and spans in observability
LiveView’s influence on deployments and WebSocket behavior
Mitigating downstream effects of socket reconnections
Contextual debugging for system behavior insights
Observability strategies for small vs. large-scale apps
OpenTelemetry for vendor-agnostic instrumentation
Leveraging OpenTelemetry contrib libraries for easy setup
Elixir’s telemetry library as an ecosystem cornerstone
Tracing as the first step in observability
Differentiating observability from business analytics
Profiling with OpenTelemetry Erlang project tools
The value of profiling for performance insights
Making observability tools accessible and impactful for developers

Links Mentioned

https://www.carscommerce.inc/
https://www.cars.com/
https://hexdocs.pm/telemetry/readme.html
https://kubernetes.io/
https://github.com/ninenines/cowboy
https://hexdocs.pm/bandit/Bandit.html
https://hexdocs.pm/broadway/Broadway.html
https://hexdocs.pm/oban/Oban.html
https://www.dynatrace.com/
https://www.jaegertracing.io/
https://newrelic.com/
https://www.datadoghq.com/
https://www.honeycomb.io/
https://fly.io/phoenix-files/how-phoenix-liveview-form-auto-recovery-works/
https://www.elastic.co/
https://opentelemetry.io/
https://opentelemetry.io/docs/languages/erlang/
https://opentelemetry.io/docs/concepts/signals/traces/
https://opentelemetry.io/docs/specs/otel/logs/
https://github.com/runfinch/finch
https://hexdocs.pm/telemetry_metrics/Telemetry.Metrics.html
https://opentelemetry.io/blog/2024/state-profiling
https://www.instrumentingelixir.com/
https://prometheus.io/
https://www.datadoghq.com/dg/monitor/ts/statsd/
https://x.com/kayserzl
https://github.com/zkayser
https://bsky.app/profile/ethangunderson.com
https://github.com/open-telemetry/opentelemetry-collector-contrib

Special Guests: Ethan Gunderson and Zack Kayser.

Scaling the Daylite Apple-Native CRM Using Elixir with AJ

podcast@smartlogic.io (SmartLogic LLC) — Thu, 05 Dec 2024 06:30:00 -0500

AJ (Alykhan Jetha), CEO and CTO of Marketcircle, joins the Elixir Wizards to share his experience building and evolving Daylite, their award-winning CRM and business productivity app for Apple users. He details his experiences as a self-taught programmer and how Marketcircle has navigated pivots, challenges, and opportunities since its founding in 1999.

AJ explains why they migrated Daylite’s backend to Elixir, focusing on their sync engine, which demands high concurrency and fault tolerance. He highlights how Elixir has improved performance, reduced cloud costs, and simplified development with its approachable syntax and productive workflows.

The conversation also touches on the technical hurdles of deploying native apps for Apple devices and the potential for integrating new technologies like LiveView Native to streamline cross-platform development.

For technical founders, AJ emphasizes the importance of leveraging your strengths (“superpowers”), staying deeply connected to the development process, and finding stability in tools like Elixir amidst a rapidly evolving tech ecosystem. He also shares Marketcircle’s roadmap for migrating more customers to Elixir-powered systems and explores the potential for new features in their native apps.

Tune in for insights on building resilient systems, navigating technical and business challenges, and how Elixir is shaping Marketcircle’s future.

Topics discussed in this episode:

AJ’s journey as a self-taught programmer and entrepreneur
Marketcircle’s evolution since 1999 and lessons from their pivots
Daylite’s growth as a flagship product for Apple users
Migrating to Elixir for high concurrency and fault tolerance
How Elixir improved performance and reduced cloud costs
The simplicity of Elixir and its impact on developer onboarding
Challenges in managing a growing microservices architecture
Insights into deploying native apps for the Apple ecosystem
Exploring LiveView Native for future cross-platform development
Advice for technical founders: leveraging your superpowers
Staying connected to development to maintain system understanding
The role of Elixir in improving development efficiency and stability
Planning gradual customer migrations to an Elixir-powered backend
Potential new features for Daylite’s native apps
Benefits of collaboration with the Elixir community
#ElixirMullet -- native app in the front, Elixir in the back
Navigating a rapidly evolving tech ecosystem as a founder
Leveraging Elixir to future-proof Marketcircle’s systems
Balancing technical and business priorities in a startup environment
AJ’s thoughts on the future of Elixir in powering business tools

Links mentioned:

https://www.marketcircle.com/
Daylite.app
https://www.nextcomputers.org/
https://www.digitalocean.com/
Python Async https://docs.python.org/3/library/asyncio.html
https://github.com/sinatra/sinatra
https://github.com/dependabot
https://kafka.apache.org/
https://www.djangoproject.com/
https://github.com/socketry/falcon
https://github.com/puma/puma
https://www.swift.org/blog/announcing-swift-6/
https://en.wikipedia.org/wiki/Async/await
https://www.ffmpeg.org/
https://www.sqlite.org/
https://github.com/commanded/commanded
https://pragprog.com/titles/khpes/real-world-event-sourcing/
https://en.wikipedia.org/wiki/Ship_of_Theseus
https://reactnative.dev/
https://www.electronjs.org/
https://en.wikipedia.org/wiki/WebOS
https://www.linkedin.com/in/alykhanjetha/
https://bsky.app/profile/ajetha.bsky.social

Special Guest: Alykhan Jetha.

Creating the Castmagic AI-Powered Content Workflow Platform with Justin Tormey

podcast@smartlogic.io (SmartLogic LLC) — Thu, 28 Nov 2024 06:30:00 -0500

Justin Tormey, co-founder of Castmagic, joins the Elixir Wizards to discuss building an AI-powered content creation app. Castmagic repurposes audio and video into social media posts, blog articles, newsletters, and more. The tech stack leverages OpenAI and Anthropic LLMs with Elixir as the coordination layer and Phoenix LiveView powering the front end.

Justin dives into the technical details of Castmagic, including the integration of JavaScript libraries like ProseMirror and TipTap through LiveSvelte, as well as enabling real-time collaboration with CRDTs and YDoc. He shares the benefits and challenges of using Elixir for rapid development, as well as the trade-offs between custom code and off-the-shelf solutions.

The conversation also covers Justin’s entrepreneurial journey, highlighting the advantages of bootstrapping over venture capital, the importance of acquiring early customers, and creative marketing strategies like affiliate programs and software marketplaces.

Whether you're an Elixirist exploring machine learning or an aspiring tech founder, tune in to learn more about AI with Elixir, navigating startup challenges, and turning ideas into impactful software.

Topics discussed in this episode:

Building Castmagic to generate content from audio and video for creators
Using AI services like OpenAI and Anthropic for transcription and workflows
Elixir as the coordination layer for complex processes
Rapid UI development with Phoenix LiveView
Integrating rich text editing libraries through LiveSvelte
Enabling collaborative editing with CRDTs and YDoc
Balancing offline functionality with cloud-based AI tools
Challenges of working with external AI services
Exploring the future of multimodal AI in product development
Bootstrapping vs. venture capital: benefits and challenges
Strategies for finding distribution channels and early adopters
Creative approaches to marketing, including affiliates and marketplaces
Balancing engineering efforts with customer and business needs
Practical advice for navigating the early stages of a startup

Special Guest: Justin Tormey.

Creating the Standd AI-Native Due Diligence Platform with Stephen Solka

podcast@smartlogic.io (SmartLogic LLC) — Thu, 21 Nov 2024 06:30:00 -0500

Stephen Solka, CTO and co-founder of Standd.io, joins Elixir Wizards Owen and Charles to share the journey of building an AI-native deal intelligence and due diligence platform. Designed to streamline document analysis and text generation for venture capital firms, Standd.io leverages large language models and AI tools to address key customer pain points in document workflows.

Stephen explains how Elixir and Phoenix LiveView enabled rapid UI iteration and seamless integration between the front-end and back-end.

The conversation also explores the human side of startup life. Stephen reflects on balancing tech debt with customer demands, the value of accelerators in building networks and securing funding, and the challenges of pricing in early-stage startups. He emphasizes the importance of validating ideas with potential customers and learning from the hurdles of growing a business.

Tune in for insights on leveraging AI in Elixir, solving real-world problems, and navigating the journey from concept to company.

Topics discussed in this episode:

The journey from self-taught programmer to CTO
The perks of Phoenix LiveView for rapid UI development
Integrating front-end and back-end technologies
AI tools for code generation
How early adopters balance functionality with product polish
Validating ideas and understanding customer needs
The impact of accelerators on networking and fundraising
Approaches to managing pricing strategies for startups
Balancing technical debt with feature development
The role of telemetry and error reporting in product development
Creating collaborative and supportive tech communities
Educating users on AI’s capabilities and limitations
The broader implications of AI tools across industries

Links Mentioned

Contact Stephen & Julie at Standd: founders@standd.io
https://www.standd.io/
https://www.digitalocean.com/community/tutorials/gangs-of-four-gof-design-patterns
https://www.thriftbooks.com/w/code-complete_steve-mcconnell/248753/item/15057346/
https://aws.amazon.com/sagemaker/
https://www.anthropic.com/
https://getoban.pro/
https://kubernetes.io/
https://www.apollographql.com/
https://aws.amazon.com/startups/accelerators
https://accelerate.techstars.com/
https://aider.chat/
https://github.com/Aider-AI/aider
https://neovim.io/
https://ui.shadcn.com/
https://tailwindui.com/
https://www.ycombinator.com/
https://www.thriftbooks.com/w/close-to-the-machine-technophilia-and-its-discontents_ellen-ullman/392556

Special Guest: Stephen Solka.

Creating the WebAuthn Components Library for Phoenix LiveView Apps with Owen Bickford

podcast@smartlogic.io (SmartLogic LLC) — Thu, 14 Nov 2024 06:30:00 -0500

Today on Elixir Wizards, Owen Bickford, fellow Wizard and creator of the WebauthnComponents library, joins us to talk about building passwordless authentication for Phoenix LiveView applications. Owen walks us through the evolution of authentication—touching on everything from plain text passwords to multi-factor setups—and explains the security flaws and user experience issues each method presents. He describes passkeys, a solution based on the WebAuthn API, which improves security and ease of use.

The conversation covers cross-device support for passkeys, the role of password managers in keeping credentials synced, and ideas for enhancing WebauthnComponents, like supporting multiple passkeys per account. Owen invites listeners to contribute to the library’s development on GitHub and emphasizes the role passkeys play in improving app security and user experience.

Topics discussed in this episode:

Passkeys and the shift toward passwordless authentication
WebAuthn API and its role in secure login systems
Creating the WebauthnComponents library for Phoenix LiveView
History of authentication from basic passwords to multi-factor approaches
Security gaps and user experience challenges with traditional methods
Asymmetric cryptography’s impact on secure logins
Hardware-based credential storage and generation with Trusted Platform Modules
Structure and components of the WebAuthn library: dependencies, LiveViews, and Ecto schemas
Live components for real-time server-browser interactions
Passkeys as a primary or secondary authentication method
Key business considerations when choosing authentication methods
Cross-device support for passkeys and credential syncing
Strategies for passkey recovery if devices are lost
Ensuring secure access in unattended environments
Elixir’s ecosystem advantages for building authentication systems
Simplifying JavaScript complexity within Elixir projects
Future-proofing WebAuthn Components for seamless updates
Using Igniter to enhance customization and refactoring
Developer-friendly tools for secure authentication
Inviting community contributions on GitHub and the Elixir forum
Plans for telemetry and performance tracking
Why adopting passkeys is a win for app security and user experience

Links mentioned:

https://github.com/liveshowy/webauthn_components
https://en.wikipedia.org/wiki/Salt_(cryptography)
https://en.wikipedia.org/wiki/Rainbow_table
https://en.wikipedia.org/wiki/Multi-factor_authentication
https://oauth.net/2/
https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API
https://www.w3.org/TR/webauthn-3/
https://www.microsoft.com/en-us/windows/tips/windows-hello
https://trustedcomputinggroup.org/resource/trusted-platform-module-tpm-summary/
https://hexdocs.pm/phoenix/mix_phx_gen_auth.html
https://en.wikipedia.org/wiki/Public-key_cryptography
SSH Protocol (Secure Shell) https://en.wikipedia.org/wiki/Secure_Shell
https://www.yubico.com/products/yubikey-5-overview/
https://fidoalliance.org/how-fido-works/
https://1password.com/
https://keepassxc.org/
https://hexdocs.pm/ecto_ulid/Ecto.ULID.html
https://en.wikipedia.org/wiki/Universally_unique_identifier
https://hexdocs.pm/ecto/Ecto.Schema.html
https://hexdocs.pm/sourceror/
https://github.com/ash-project/igniter
Forum thread:
https://elixirforum.com/t/webauthnlivecomponent-passwordless-auth-for-liveview-apps/49941

Creating a Terrestrial Telescope using Nerves & LiveView with Lucas Sifoni

podcast@smartlogic.io (SmartLogic LLC) — Thu, 07 Nov 2024 06:15:00 -0500

Today on Elixir Wizards, indie developer Lucas Sifoni shares his experience prototyping a remote-controlled terrestrial telescope using Elixir, Nerves, Rust, and various hardware components.

Lucas explains the basic components of a telescope, the challenges he faced during the development process, and the benefits of using Elixir and Nerves for hardware projects. Lucas emphasizes the importance of simulating hardware components and testing assumptions before working with physical devices, as well as the value of literate programming and executable blog posts for documenting and sharing the process.

Lucas encourages listeners to explore Nerves and build their own hardware projects. He also gives a shout-out to the Nerves core team for their incredible work.

Topics discussed in this episode:

Challenges in optimizing wiring and PCB design for the prototype
Benefits of Elixir and Nerves for hardware projects
Communicating with Arduinos using serial connections and pattern matching
Leveraging binary pattern matching and construction in Elixir for hardware
Balancing educational value and real-world usability
Learning CID software and parametric design for 3D printing components
Growing interest in Nerves and hardware projects within the Elixir community
Simulating hardware components and testing assumptions before physical implementation
Literate programming and executable blog posts for documenting hardware projects
Using Elixir's interoperability with Rust for performance-critical tasks
Elixir's low fragmentation and high-quality libraries for various domains
Potential for using Livebook in hardware projects, with some limitations
Encouraging listeners to explore Nerves and build their own hardware projects

Links mentioned

https://lucassifoni.info/
https://www.rust-lang.org/
https://go.dev/
https://lisp-lang.org/
https://ubuntu.com/
https://hexdocs.pm/iex/IEx.html
https://nerves-project.org/
https://lucassifoni.info/blog/prototyping-elixir-telescope-code-beam/
https://github.com/Lucassifoni/oiseaux
https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
https://www.raspberrypi.com/
https://mangopi.org/
https://store.arduino.cc/products/arduino-nano
https://elixir-circuits.github.io/
https://www.erlang.org/doc/apps/runtime_tools/scheduler.html
Binary pattern matching in Elixir with PNG parsing example https://zohaib.me/binary-pattern-matching-in-elixir/
Lucas’ Code Beam Talk: https://www.youtube.com/watch?v=q7bleFzA11c
https://github.com/membraneframework-labs
https://github.com/talklittle/ffmpex
https://studio.blender.org/training/3d-printing/
https://www.autodesk.com/products/fusion-360/personal
https://en.wikipedia.org/wiki/Parametric_design
https://www.exem.fr/
https://www.kikk.be/exhibitions/collectif-lab212-nicolas-guichard-beatrice-lartigue/
https://livebook.dev/
https://github.com/elixir-nx/bumblebee
https://github.com/rusterlium/rustlerhttps://www.youtube.com/watch?v=q7bleFzA11c

Special Guest: Lucas Sifoni.

Creating a Local-First Offline-Enabled LiveView PWA with Tony Dang

podcast@smartlogic.io (SmartLogic LLC) — Thu, 31 Oct 2024 06:00:00 -0400

Today in the Creator’s Lab, Tony Dang joins Elixir Wizards Sundi Myint and Owen Bickford to break down his journey of creating a local-first, offline-ready to-do app using Phoenix LiveView, Svelte, and CRDTs (Conflict-free Replicated Data Types).

Tony explains why offline functionality matters and how this feature can transform various apps. He shares insights on different libraries, algorithms, and techniques for building local-first experiences and highlights the advantages of Elixir and Phoenix LiveView.

Tony also shares his go-to tools, like Inertia.js for connecting Phoenix backends with JavaScript frontends, and favorite Elixir packages like Oban, Joken, and Hammer, offering a toolkit for anyone building powerful, adaptable applications.

Topics discussed in this episode:

Tony Dang's background from mechanical engineer to web developer
Building an offline-enabled to-do app with Phoenix LiveView and Svelte
CRDTs: Conflict-free Replicated Data Types for merging changes offline
How to make a LiveView app work offline
Sending full state updates vs. incremental updates for performance optimization
Inspiring others through open-source projects and community contributions
Learning vanilla Phoenix and Channels to understand LiveView better
Handling stale CSRF tokens when reconnecting to a LiveView app offline
Exploring service workers and browser APIs for managing offline connectivity
Balancing the use of JavaScript and Elixir in web development
Fostering a supportive and inspiring Elixir community

Links mentioned:

Special Guest: Tony Dang.

Creating VintageCell: Nerves, PCBs, and GenStateMachine with Bryan Green

podcast@smartlogic.io (SmartLogic LLC) — Thu, 24 Oct 2024 06:00:00 -0400

Today on Elixir Wizards, Bryan Green shares how he transformed a vintage 1930s rotary phone into a fully functional cell phone using Elixir, Nerves, and a mix of hardware components.

Bryan shares the highs and lows of his project, from decoding rotary dial clicks to troubleshooting hardware issues with LED outputs. He explains why Nerves was the perfect fit for this project, offering SSH access, over-the-air updates, and remote debugging. You’ll also hear how Elixir’s concurrency model helped him manage hardware inputs and outputs efficiently using GenStateMachine and Genservers.

Elixir and Nerves really shine when modeling real-world systems. Bryan dives into how he used a finite state machine to track the phone’s states and handled inputs from the rotary dial and hook switch via GPIO.

For hardware enthusiasts, Bryan’s advice is to embrace this “golden age” of DIY electronics. Whether you're experienced with embedded systems or just curious on where to start, Bryan's VintageCell can inspire you to tinker with a hardware engineering project.

Key topics discussed in this episode:

Advantages of functional programming and immutability in Elixir
Building hardware projects using Adafruit components
Why Nerves was the best choice for the VintageCell project
Interpreting rotary dial clicks using GPIO and circuits.gpio
Troubleshooting hardware issues with LED diagnostics
Challenges in optimizing wiring and PCB design
Benefits of Nerves: SSH access, OTA updates, and remote debugging
Modeling real-world systems with Elixir and Nerves
Implementing a finite state machine with GenStateMachine
Managing input with Genservers for rotary dial and hook switch
Leveraging community resources like Discord, Elixir Slack, and forums
Practical advice for keeping hardware projects on track
Potential applications from SMS servers to home automation

Links mentioned:

Vintage Cellphone: Bridging the Past and Future with Elixir
Seven Languages in Seven Weeks https://pragprog.com/titles/btlang/seven-languages-in-seven-weeks/
Seven More Languages https://pragprog.com/titles/7lang/seven-more-languages-in-seven-weeks/
Node.js https://github.com/nodejs
https://nerves-project.org/
https://www.arduino.cc/
Adafruit Circuit Playground https://www.adafruit.com/category/965
Adafruit 3D Printed Star Trek Communicator https://learn.adafruit.com/3d-printed-star-trek-communicator
Adafruit FONA 3G Cellular + GPS Breakout https://learn.adafruit.com/adafruit-fona-3g-cellular-gps-breakout/overview
https://github.com/elixir-circuits/circuits_gpio
Nerves SSH https://hex.pm/packages/nerves_ssh
OTA (over-the-air) Updates with NervesHub https://www.nerves-hub.org/
https://github.com/kicad
Waveshare 4G Hat for Raspberry Pi https://www.waveshare.com/sim7600e-h-4g-hat.htm
https://hexdocs.pm/gen_state_machine/GenStateMachine.html
https://hexdocs.pm/elixir/GenServer.html
https://www.sparkfun.com/
https://www.digikey.com/
USB-C Gadget Mode with Nerves https://github.com/nerves-project/nerves_system_rpi4/issues/18
https://livebook.dev/
https://codestorm.me/
https://github.com/codestorm1/vintage_cell/

Special Guest: Bryan Green.

Creating the Igniter Code Generation Framework with Zach Daniel

podcast@smartlogic.io (SmartLogic LLC) — Thu, 17 Oct 2024 06:00:00 -0400

To kick off Elixir Wizards Season 13, The Creator's Lab, we're joined by Zach Daniel, the creator of Igniter and the Ash framework. Zach joins hosts Owen Bickford and Charles Suggs to discuss the mechanics and aspirations of his latest brainchild, Igniter—a code generation and project patching framework designed to revolutionize the Elixir development experience.

Igniter isn’t just about generating code; it’s about generating smarter code. By leveraging tools like Sourcerer and Rewrite, Igniter allows developers to modify source code and batch updates by directly interacting with Elixir's AST instead of regex patching. This approach streamlines new project setup and package installations and enhances overall workflow.

They also discuss the strategic implications of Igniter for the broader Elixir community. Zach hopes Igniter will foster a more interconnected and efficient ecosystem that attracts new developers to Elixir and caters to the evolving needs of seasoned Elixir engineers.

Topics discussed in this episode:

Advanced package installation and code generation improve the developer experience
Scripting and staging techniques streamline project updates
Innovative methods for smoother installation processes in Elixir packages
High-level tools apply direct patches to source code
Progressive feature additions simplify the mix phx.new experience
Chaining installers and composing tasks for more efficient project setup
Continuous improvement in developer experiences to boost Elixir adoption
Encourage listeners to collaborate by sharing code generation patterns
Introduction of a new mix task aimed at removing the "unless" keyword in preparation for Elixir 1.18
You can learn more in the upcoming book "Building Web Applications with Ash Framework" by Zach and Rebecca

Links mentioned:

https://smartlogic.io/
https://alembic.com.au/blog/igniter-rethinking-code-generation-with-project-patching
https://hexdocs.pm/igniter/readme.html
https://github.com/ash-project/igniter
https://www.zachdaniel.dev/p/serialization-is-the-secret
https://www.zachdaniel.dev/p/welcome-to-my-substack
https://ash-hq.org/
https://hexdocs.pm/sourceror/readme.html
https://smartlogic.io/podcast/elixir-wizards/s10-e09-hugo-lucas-future-of-elixir-community/
https://github.com/hrzndhrn/rewrite
https://github.com/zachdaniel
https://github.com/liveshowy/webauthn_components
https://hexdocs.pm/elixir/Regex.html
https://github.com/msaraiva/vscode-surface
https://github.com/swoosh/swoosh
https://github.com/erlef/oidcc
https://alembic.com.au/
https://www.zachdaniel.dev/

Special Guest: Zach Daniel.

Elixir Wizards X Thinking Elixir ElixirConf 2024 Hype-isode

podcast@smartlogic.io (SmartLogic LLC) — Tue, 23 Jul 2024 06:00:00 -0400

The Elixir Wizards and Thinking Elixir podcasts join forces to bring you a special hype-isode for ElixirConf 2024 in Orlando, Florida. Hosts Owen, Sundi, David, and Mark discuss their favorite moments from past conferences and offer a sneak peek into what this year's event has in store.

From insightful training classes to thought-provoking talks on topics like LiveView, data processing, Nerves, and machine learning—there's something for every Elixirist and Elixir-curious software developer. In this episode, we share tips on making the most of the conference, whether you're there to network, learn, or just soak in the community vibes.

Want to attend ElixirConf in Orlando from August 27th-30th, 2024? Use code ELIXIRPODCAST at checkout to get a $50 discount on your tickets here: https://ti.to/elixirconf/2024

Key topics discussed in this episode:

Favorite moments and experiences from previous ElixirConf events
How to network and make the most of your conference attendance
Training classes and talks we're looking forward to this year
Keynotes from prominent Elixir community figures
Chris McCord's keynote: TBD (Could it be a LiveView 1.0 announcement?!)
Benefits of attending ElixirConf: learning, networking, community immersion
Virtual attendance options for those unable to attend in person
Early bird ticket prices and special discount code "ELIXIRPODCAST" for $50 off
Why you should step out of your comfort zone and engage with others
Passion and energy of Elixir community members at ElixirConf
Mentorship opportunities: connect with experienced Elixir developers
Exploring Orlando attractions during ElixirConf 2024 downtime
An invitation to join us at ElixirConf 2024 and immerse yourself in the Elixir community

Links mentioned:

https://2024.elixirconf.com/
https://hexdocs.pm/ecto/Ecto.html
https://fly.io/
https://brainlid.org/
https://github.com/brainlid/
https://www.meetup.com/austin-elixir/
https://grox.io/
https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html
https://opentelemetry.io/docs/languages/erlang/
https://ash-hq.org/
https://alembic.com.au/
Functional IoT with Elixir and Nerves - Justin Schneck | Craft 2019
https://docs.nerves-hub.org/
https://nerves-project.org/
https://getoban.pro/
https://hexdocs.pm/broadway/Broadway.html
https://developer.farm.bot/v15/docs/farmbot-os.html
Leaving Everything Behind For Elixir - Theo’s video
Phoenix LiveView Is Making Me Reconsider React... - Theo’s other video
Podcast: Thinking Elixir 206: BeamOps - DevOps on the BEAM

Special Guests: David Bernheisel and Mark Ericksen.

"The Past is Your Teacher" with Alicia Brindisi and Bri LaVorgna

podcast@smartlogic.io (SmartLogic LLC) — Thu, 30 May 2024 06:15:00 -0400

It’s the season finale of Elixir Wizards Office Hours! SmartLogic’s Project Manager Alicia Brindisi and VP of Delivery Bri LaVorgna join host Dan to delve into the agile ceremony of retrospectives. They explore the vital role of retrospectives in Agile project management and unveil practical strategies for enhancing their effectiveness.

Alicia and Bri break down the elements of a successful retrospective. They cover everything from meticulous preparation to facilitation techniques, and how to choose the best format for fostering open dialogue and actionable results. Learn how to navigate common obstacles and guide discussions toward productive, solution-focused outcomes.

Throughout the episode, they emphasize the transformative potential of retrospectives within the Agile framework, portraying them not just as a procedural activity, but as a catalyst for continuous team growth and project success.

Key topics discussed in this episode:

Mastering the full potential of retrospectives in Agile environments
Best practices for effective preparation and facilitation
Choosing the right format to suit your team's dynamics
Strategies for overcoming typical challenges during retrospectives
Techniques for addressing and resolving interpersonal conflicts constructively
The critical importance of valuing each team member’s perspective
Practical advice on applying insights from retrospectives to enact organizational changes
Tailoring and refining retrospectives to meet your team’s unique requirements

Links mentioned:

SmartLogic https://smartlogic.io/
SmartLogic LinkedIn https://www.linkedin.com/company/smartlogic-io
Contact Bri Bri@smartlogic.io
Retrium Retrospectives for Scrum & Agile Teams https://www.retrium.com/
4Ls Retrospective Template https://www.retrium.com/retrospective-techniques/4ls
Start Stop Continue Retrospective https://www.retrium.com/retrospective-techniques/start-stop-continue
Sailboat Retrospective https://www.retrium.com/retrospective-techniques/sailboat
Starfish Retrospective https://www.retrium.com/retrospective-techniques/starfish
ClickUp Project Management Platform https://clickup.com/teams/project-management
Asana Task Manager http://www.asana.com
Jira Project Management Tool https://www.atlassian.com/software/jira

Special Guests: Alicia Brindisi and Bri LaVorgna.

"So You've Been Hired" with Emma Whamond and Micaela Cunha

podcast@smartlogic.io (SmartLogic LLC) — Thu, 23 May 2024 06:15:00 -0400

In Office Hours Episode 10, SmartLogic’s newest developers, Emma Whamond and Micaela Cunha, join Elixir Wizard Owen Bickford to discuss their onboarding experiences, joining a new engineering team, and navigating an unfamiliar codebase. They share tips and challenges on learning new programming languages like Ruby and Elixir while ramping up for active client projects. Emma and Micaela emphasize the value of starting with tests and seeking guidance from teammates when diving into unfamiliar projects.

Our guests provide valuable guidance for anyone navigating the transition into a new software development team, highlighting the importance of collaboration, continuous learning, and community support in the tech industry.

Key topics discussed in this episode:

What to expect when joining a new engineering team
Navigating existing codebases as a new hire in Elixir and Ruby
Applying previous work experience to software development
The importance of tests and team communication in unfamiliar projects
Learning Ruby as a C++ and JavaScript developer
Differences between dynamic and static typing
Building team camaraderie and intentionality in remote work environments
The steep learning curve of the onboarding process, including documentation, codebases, and client meetings
Relying on teammates for guidance and overcoming the fear of asking too many questions
Updating documentation within project repositories
Learning team dynamics and identifying domain experts for targeted assistance
Domain-specific knowledge: being a senior developer in one language vs. another
Building friendships and connections within local tech communities
The welcoming and supportive nature of the tech industry for newcomers

Links mentioned:

Elixir Programming Language https://elixir-lang.org/
Ruby on Rails https://www.ruby-lang.org/en/
Ruby Koans - Learn Ruby language, syntax, structure https://www.rubykoans.com/
Elixir Language Learning Exercises (Elixir Koans) https://github.com/elixirkoans/elixir-koans
The PETAL Stack in Elixir https://thinkingelixir.com/petal-stack-in-elixir/
Alpine JS Lightweight JavaScript Framework https://alpinejs.dev/
Phoenix LiveView https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
WebAuthn Components passwordless authentication to LiveView applications
https://github.com/liveshowy/webauthn_components
Gleam functional language for building type-safe, scalable systems https://gleam.run/
The Future of Types in Elixir with José Valim, Guillaume Duboc, and Giuseppe Castagna https://smartlogic.io/podcast/elixir-wizards/s10-e12-jose-guillaume-giuseppe-types-elixir/
Git-Blame https://git-scm.com/docs/git-blame
nix store https://nixos.org/manual/nix/stable/command-ref/nix-store
Code and Coffee https://codeandcoffee.org/

Special Guests: Emma Whamond and Micaela Cunha.

"From Inspiration to Execution" with Camber Griffin

podcast@smartlogic.io (SmartLogic LLC) — Thu, 16 May 2024 06:15:00 -0400

In Episode 9 of Elixir Wizards Office Hours, we dive into task writing and backlog grooming, transforming ideas from the discovery phase into actionable tickets. Join SmartLogic Developer Camber Griffin and hosts Dan Ivovich and Owen Bickford as they explore the intricacies of task writing, ticket grooming, estimation, and backlog management in the software development lifecycle.

They emphasize crafting clear, detailed tickets that act as comprehensive guides for development teams. A well-written ticket does more than outline what needs to be built—it facilitates collaboration by including entry points, linking to essential documentation, defining acceptance criteria, detailing QA steps, and identifying potential risks and future hurdles.

Key topics discussed in this episode:

Crafting actionable development tickets from inspiration
Achieving the optimal level of detail in tickets
Tailoring ticket content for developers, QA, and stakeholders
Standardizing ticket format with templates
Structurally breaking down tasks into manageable sections
Ensuring flexibility in implementation while maintaining clear specifications
Proactively discussing architectural and design approaches
Incorporating related documentation within tickets
Clarifying acceptance criteria and QA procedures
Accurately estimating task effort and complexity
Collaboratively grooming tasks with cross-functional teams
Adjusting tickets to evolving requirements
Strategically planning for uncertainties and out-of-scope concerns
Managing and versioning ongoing documentation
Keeping the backlog clean, prioritized, and relevant
Mapping dependencies among interconnected tasks

Links mentioned:

Jira Work Management https://www.atlassian.com/software/jira
ClickUp Project Management Platform https://clickup.com/teams/project-management
GitHub Projects https://docs.github.com/en/issues/planning-and-tracking-with-projects
Zube Agile Project Management https://zube.io/
Pivotal Tracker Agile Project Management Tool https://www.pivotaltracker.com/
Trak Portfolio Management System https://pd-trak.com/
ClearCase Software Configuration Mgmt www.ibm.com/products/devops-code-clearcase
Oban Job Processing in Elixir https://github.com/sorentwo/oban

Special Guest: Camber Griffin.

"DevOps: From Code to Cloud" with Dan Ivovich

podcast@smartlogic.io (SmartLogic LLC) — Thu, 09 May 2024 06:15:00 -0400

In Elixir Wizards Office Hours Episode 8, hosts Sundi Myint and Owen Bickford lead an engaging Q&A session with co-host Dan Ivovich, diving deep into the nuances of DevOps. Drawing from his extensive experience, Dan navigates topics from the early days before Docker to managing diverse polyglot environments and optimizing observability.

This episode offers insights for developers of all levels looking to sharpen their DevOps skills. Explore the realms of Docker, containerization, DevOps workflows, and the deployment intricacies of Elixir applications.

Key topics discussed in this episode:

Understanding DevOps and starting points for beginners
Best practices for deploying applications to the cloud
Using Docker for containerization
Managing multiple programming environments with microservices
Strategies for geographic distribution and ensuring redundancy
Localization considerations involving latency and device specs
Using Prometheus and OpenTelemetry for observability
Adjusting scaling based on application metrics
Approaching failure scenarios, including database migrations and managing dependencies
Tackling challenges in monitoring setups and alert configurations
Implementing incremental, zero-downtime deployment strategies
The intricacies of hot code upgrades and effective state management
Recommended learning paths, including Linux and CI/CD workflows
Tools for visualizing system health and monitoring
Identifying actionable metrics and setting effective alerts

Links mentioned:

Ansible open source IT automation engine https://www.ansible.com/
Wikimedia engine https://doc.wikimedia.org/
Drupal content management software https://www.drupal.org/
Capistrano remote server automation and deployment https://capistranorb.com/
Docker https://www.docker.com/
Circle CI CI/CD Tool https://circleci.com/
DNS Cluster https://hex.pm/packages/dns_cluster
ElixirConf 2023 Chris McCord Phoenix Field Notes https://youtu.be/Ckgl9KO4E4M
Nerves https://nerves-project.org/
Oban job processing in Elixir https://getoban.pro/
Sidekiq background jobs for Ruby https://sidekiq.org/
Prometheus https://prometheus.io/
PromEx https://hexdocs.pm/prom_ex/PromEx.html
GitHub Actions - Setup BEAM: https://github.com/erlef/setup-beam
Jenkins open source automation server https://www.jenkins.io/
DataDog Cloud Monitoring https://www.datadoghq.com/

"Printing is Ugly" with Joel Meador and Charles Suggs

podcast@smartlogic.io (SmartLogic LLC) — Thu, 02 May 2024 06:15:00 -0400

In Episode 7 of Elixir Wizards Office Hours, SmartLogic Engineers Joel Meador and Charles Suggs join host Owen Bickford to tackle the often tricky task of adding print functionality to web applications. They discuss their recent experiences with browser-based printing and the hurdles of cross-browser compatibility, consistent styling, and dynamic content generation, such as headers and footers.

The trio delves into the limitations of current printing capabilities in browsers, the potential of server-side PDF generation, and the necessity of juggling separate templates for web and print. They also consider accessibility for printed content and the demands of delivering high-fidelity, pixel-perfect prints.

Throughout the episode, Joel, Charles, and Owen offer up practical advice for developers grappling with similar issues, emphasizing the need for thorough research, proactive problem-solving, and the exploration of both in-browser and external PDF generation solutions.

Key topics discussed in this episode:

Real-world experiences with software project printing
Navigating the limitations of browser-based printing
Ensuring cross-browser compatibility and consistent layout
Generating dynamic content for print versions
Exploring server-side PDF generation and its advantages
Balancing design consistency across web and print formats
Addressing accessibility in printed outputs
Overcoming the unique challenges of high-accuracy printing requirements
Practical tips for researching and implementing printing solutions
Handling complex data presentations like tables in print
Evaluating the pros and cons of different printing APIs
Understanding the distinction between web viewing and printing needs
Innovating with mixed content in PDF generation
Learning from past printing challenges and planning for future improvements

Links mentioned:

CSS3 https://css3.com/
WeasyPrint https://github.com/Kozea/WeasyPrint
WebKit https://webkit.org/
Pdf.js https://github.com/mozilla/pdf.js
YesLogic Prince 15 https://www.princexml.com/
PrintXML https://gist.github.com/craiga/2934093
PDF/A https://en.wikipedia.org/wiki/PDF/A
The PDF/A Family of Archiving Standards https://www.pdflib.com/pdf-knowledge-base/pdfa/the-pdfa-standards/
PDF/X https://en.wikipedia.org/wiki/PDF/X
Microsoft Encarta https://en.wikipedia.org/wiki/Encarta

Special Guests: Charles Suggs and Joel Meador.

"Keeping it Fresh" with Bilal Hankins and Anna Dorigo

podcast@smartlogic.io (SmartLogic LLC) — Thu, 25 Apr 2024 06:00:00 -0400

In Office Hours Episode 6, SmartLogic Developers Anna Dorigo and Bilal Hankins join Elixir Wizards Sundi and Dan to discuss their experiences maintaining a decade-old Ruby on Rails codebase.

They delve into the critical importance of deeply understanding the codebase, keeping dependencies current, and adapting to the original application's evolving priorities and design choices.

The conversation spans a range of topics, including accessibility, testing, monitoring, and the challenges of deploying database migrations in production environments. The guests share effective strategies for sustaining and enhancing older codebases, such as employing automated tools, performing code audits, and adhering to clean coding principles.

Key topics discussed in this episode:

Grasping the legacy codebase and its historical context
Overcoming accessibility issues in older applications
Safe dependency management and upgrades
The effects of application scaling on database performance
The critical role of comprehensive test suites in legacy systems
Using tools like Sentry for error tracking and performance monitoring
The benefits of automated security and dependency scans
Juggling client needs with budget constraints
Local simulation techniques for large datasets
The value of iterative code reviews and maintaining clean code
Utilizing git history for contextual understanding
Onboarding strategies for legacy projects
Removing obsolete code and avoiding "magic numbers"
Importance of descriptive naming for better code clarity
Leveraging a rich repository of example code for learning and reference
Proactive code audits to anticipate issues
Managing pull request sizes for smoother reviews
Communicating effectively about upgrades and potential impacts
Strategies for handling large databases efficiently
Ensuring thorough test coverage
Keeping open lines of communication with clients regarding ongoing maintenance

Links mentioned:

COBOL programming language https://developer.ibm.com/languages/cobol/
Ruby on Rails https://rubyonrails.org/
ARIA Rules (Accessible Rich Internet Applications) https://www.w3.org/TR/using-aria/
Shawn Vo on Elixir as a Competitive Advantage https://smartlogic.io/podcast/elixir-wizards/s5e5-vo/
Bundler Audit Ruby Gem https://rubygems.org/gems/bundler-audit/
Sentry application monitoring and error tracking software https://sentry.io/
Dependabot Github automated dependency updates
Mix hex.audit https://hexdocs.pm/hex/Mx.Tasks.Hex.Audit.html
Git Blame https://git-scm.com/docs/git-blame
Cow hoof trimming videos - The Hoof GP on YouTube (TW graphic imagery)

Special Guests: Anna Dorigo and Bilal Hankins.

"Saga of a Gnarly Report" with Owen and Dan

podcast@smartlogic.io (SmartLogic LLC) — Thu, 18 Apr 2024 07:00:00 -0400

In today's episode, Elixir Wizards Owen and Dan delve into the complexities of building advanced reporting features within software applications. They share personal insights and challenges encountered while developing reporting solutions for user-generated data, leveraging both Elixir/Phoenix and Ruby on Rails.

The discussion zeroes in on crucial data modeling and architectural decisions that enhance reporting efficiency and flexibility. Owen and Dan explore tactics like materialized views, event sourcing, and database triggers to optimize data handling while being mindful of UX elements like progress indicators and background job management.

They share insights on leveraging the Elixir/Beam ecosystem’s strengths—like concurrency and streamlined deployment—to tackle common reporting, caching, and integration challenges. The episode highlights the impact of reporting features across all aspects of a software application’s design and architecture.

Key topics discussed in this episode:

Reporting on assessment data, survey results, and user metrics
Differences between reporting and performance/error monitoring
Implementing reporting in Elixir/Phoenix vs. Ruby on Rails
Displaying reports in web, printable, PDF, SVG, and CSV formats
Challenges of generating PDFs for large data sets
Streaming CSV data directly to the client
Handling long-running report generation tasks
Providing progress indicators and user notifications
Strategies for canceling or abandoning incomplete reports
Tradeoffs of pre-calculating report data vs. real-time generation
Materializing views and denormalizing data for reporting
Exploring event sourcing patterns for reporting needs
Using database triggers and stored procedures for reporting
Balancing data structure optimization for reports vs. day-to-day usage
Caching report data for faster retrieval and rendering
Charting and visualization integration in reporting systems

Links mentioned:

Prometheus monitoring system & time series database https://prometheus.io/
Thinking Elixir "FLAME with Chris McCord" https://podcast.thinkingelixir.com/181
Phoenix LiveView Uploads https://hexdocs.pm/phoenix/file_uploads.html
https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.UploadWriter.html
Postgrex PostgreSQL driver for Elixir https://hexdocs.pm/postgrex/Postgrex.html
Ecto https://hexdocs.pm/ecto/Ecto.html
Heroku cloud application platform https://www.heroku.com/
Elixir Wizards S9E12 Marcelo Dominguez on Command and Query Responsibility Segregation https://smartlogic.io/podcast/elixir-wizards/s9-e12-marcelo-dominguez-cqrs/
Commanded Elixir CQRS/ES applications https://github.com/commanded/commanded
Tailwind CSS Framework https://github.com/tailwindlabs
Memcached https://memcached.org/
Redis https://redis.io/
Oban https://hexdocs.pm/oban/Oban.html
ETS https://hexdocs.pm/ets/ETS.html
Capistrano remote server automation and deployment tool https://capistranorb.com/

"Whose Tailwind is it Anyway?" with Ava Slivkoff

podcast@smartlogic.io (SmartLogic LLC) — Thu, 11 Apr 2024 08:30:00 -0400

In Elixir Wizards Office Hours Episode 4, SmartLogic Product Designer Ava Slivkoff joins hosts Sundi Myint and Owen Bickford to discuss the product designer's role in software development. Ava shares her experience navigating client expectations, software design principles, and technical constraints.

They explore the integration of design and development workflows and how designers and engineers can collaborate to meet a project's specific needs. The conversation emphasizes the value of cross-functional teams and the synergy that can arise when all team members work in harmony to bring a product to life.

Key concepts discussed in the episode:

The broad scope of the designer role in web app development
The value of an MVP in the iterative software design process
Challenges of aligning client expectations with design best practices
Pros and cons of leveraging pre-built Tailwind CSS styled components
Trends and evolution in web design aesthetics and patterns
Leveraging open-source design systems like Tailwind UI
Balancing technical constraints with design aspirations
Communication and trust-building between designers and engineers
Workflows for design handoffs and feedback loops
Importance of user flows and mapping the product experience
Challenges around the implementation of complex UI elements
Benefits of regular design review meetings and syncs
Fostering empathy and collaboration across disciplines

Links mentioned

Figma Dev Mode https://www.figma.com/dev-mode/
Tailwind CSS utility-first CSS framework https://tailwindcss.com/
Tailwind UI https://tailwindui.com/
https://devinai.ai/

Special Guest: Ava Slivkoff.

"You've Got a Job to Do" with Joel Meador

podcast@smartlogic.io (SmartLogic LLC) — Thu, 04 Apr 2024 07:00:00 -0400

Today on Elixir Wizards Office Hours, SmartLogic Engineer Joel Meador joins Dan Ivovich to discuss all things background jobs.

The behind-the-scenes heroes of app performance and scalability, background jobs take center stage as we dissect their role in optimizing user experience and managing heavy-lifting tasks away from the main application flow. From syncing with external systems to processing large datasets, background jobs are pivotal to successful application management.

Dan and Joel share their perspectives on monitoring, debugging, and securing background jobs, emphasizing the need for a strategic approach to these hidden workflows.

Key topics discussed in this episode:

The vital role of background jobs in app performance
Optimizing user experience through background processing
Common pitfalls: resource starvation and latency issues
Strategies for effective monitoring and debugging of task runners and job schedulers
Data integrity and system security in open source software
Background job tools like Oban, Sidekiq, Resque, Cron jobs, Redis pub sub
CPU utilization and processing speed
Best practices for implementing background jobs
Keeping jobs small, focused, and well-monitored
Navigating job uniqueness, locking, and deployment orchestration
Leveraging asynctask for asynchronous operations
The art of continuous improvement in background job management

Links mentioned in this episode:

https://redis.io/
Oban job processing library https://hexdocs.pm/oban/Oban.html
Resque Ruby library for background jobs https://github.com/resque
Sidekiq background processing for Ruby https://github.com/sidekiq
Delayed Job priority queue system https://github.com/collectiveidea/delayed_job
RabbitMQ messaging and streaming broker https://www.rabbitmq.com/
Mnesia distributed telecommunications DBMS https://www.erlang.org/doc/man/mnesia.html
Task for Elixir https://hexdocs.pm/elixir/1.12/Task.html
ETS in-memory store for Elixir and Erlang objects https://hexdocs.pm/ets/ETS.html
Cron - https://en.wikipedia.org/wiki/Cron
Donate to Miami Indians of Indiana https://www.miamiindians.org/take-action
Joel Meador on Tumblr https://joelmeador.tumblr.com/

Special Guest: Joel Meador.

"Discovery Discoveries" with Alicia Brindisi and Bri LaVorgna

podcast@smartlogic.io (SmartLogic LLC) — Thu, 28 Mar 2024 07:00:00 -0400

In Elixir Wizards Office Hours Episode 2, "Discovery Discoveries," SmartLogic's Project Manager Alicia Brindisi and VP of Delivery Bri LaVorgna join Elixir Wizards Sundi Myint and Owen Bickford on an exploratory journey through the discovery phase of the software development lifecycle.

This episode highlights how collaboration and communication transform the client-project team dynamic into a customized expedition. The goal of discovery is to reveal clear business goals, understand the end user, pinpoint key project objectives, and meticulously document the path forward in a Product Requirements Document (PRD).

The discussion emphasizes the importance of fostering transparency, trust, and open communication. Through a mutual exchange of ideas, we are able to create the most tailored, efficient solutions that meet the client's current goals and their vision for the future.

Key topics discussed in this episode:

Mastering the art of tailored, collaborative discovery
Navigating business landscapes and user experiences with empathy
Sculpting project objectives and architectural blueprints
Continuously capturing discoveries and refining documentation
Striking the perfect balance between flexibility and structured processes
Steering clear of scope creep while managing expectations
Tapping into collective wisdom for ongoing discovery
Building and sustaining a foundation of trust and transparency

Links mentioned in this episode:

https://smartlogic.io/
Follow SmartLogic on social media: https://twitter.com/smartlogic
Contact Bri: bri@smartlogic.io
What is a PRD? https://en.wikipedia.org/wiki/Product_requirements_document

Special Guests: Alicia Brindisi and Bri LaVorgna.

"Testing 1, 2, 3" with Joel Meador and Charles Suggs

podcast@smartlogic.io (SmartLogic LLC) — Thu, 21 Mar 2024 07:00:00 -0400

The Elixir Wizards Podcast is back with Season 12 Office Hours, where we talk with the internal SmartLogic team about the stages of the software development lifecycle. For the season premiere, "Testing 1, 2, 3," Joel Meador and Charles Suggs join us to discuss the nuances of software testing.

In this episode, we discuss everything from testing philosophies to test driven development (TDD), integration, and end-user testing. Our guests share real-world experiences that highlight the benefits of thorough testing, challenges like test maintenance, and problem-solving for complex production environments.

Key topics discussed in this episode:

How to find a balance that's cost-effective and practical while testing
Balancing test coverage and development speed
The importance of clear test plans and goals
So many tests: Unit testing, integration testing, acceptance testing, penetration testing, automated vs. manual testing
Agile vs. Waterfall methodologies
Writing readable and maintainable tests
Testing edge cases and unexpected scenarios
Testing as a form of documentation and communication
Advice for developers looking to improve testing practices
Continuous integration and deployment

Links mentioned:

https://smartlogic.io/
Watch this episode on YouTube! youtu.be/u_nx5AIvSdc
Bob Martin “Clean Code” videos - “Uncle Bob”: http://cleancoder.com/
JUnit 5 Testing for Java and the JVM https://junit.org/junit5/
ExUnit Testing for Elixir https://hexdocs.pm/ex_unit/ExUnit.html
Code-Level Testing of Smalltalk Applications https://www.cs.ubc.ca/~murphy/st_workshop/28-7.html
Agile Manifesto https://agilemanifesto.org/
Old Man Yells at Cloud https://i.kym-cdn.com/entries/icons/original/000/019/304/old.jpg
TDD: Test Driven Development https://www.agilealliance.org/glossary/tdd/
Perl Programming Language https://www.perl.org/
Protractor Test Framework for Angular and AngularJS protractortest.org/#/
Waterfall Project Management https://business.adobe.com/blog/basics/waterfall
CodeSync Leveling up at Bleacher Report A cautionary tale - PETER HASTIE
https://www.youtube.com/watch?v=P4SzZCwB8B4
Mix ecto.dump https://hexdocs.pm/ecto_sql/Mix.Tasks.Ecto.Dump.html
Apache JMeter Load Testing in Java https://jmeter.apache.org/
Pentest Tools Collection - Penetration Testing https://github.com/arch3rPro/PentestTools
The Road to 2 Million Websocket Connections in Phoenix https://www.phoenixframework.org/blog/the-road-to-2-million-websocket-connections
Donate to Miami Indians of Indiana https://www.miamiindians.org/take-action
Joel Meador on Tumblr https://joelmeador.tumblr.com/

Special Guests: Charles Suggs and Joel Meador.

Creating a Language: Elixir vs. Roc with José Valim and Richard Feldman (Elixir Wizards X Software Unscripted Podcast)

podcast@smartlogic.io (SmartLogic LLC) — Thu, 11 Jan 2024 07:00:00 -0500

For the final episode of Elixir Wizards’ Season 11 “Branching Out from Elixir,” we’re featuring a recent discussion from the Software Unscripted podcast. In this conversation, José Valim, creator of Elixir, interviews Richard Feldman, creator of Roc. They compare notes on the process and considerations for creating a language.

This episode covers the origins of creating a language, its influences, and how goals shape the tradeoffs in programming language design. José and Richard share anecdotes from their experiences guiding the evolution of Elixir and Roc. The discussion provides an insightful look at the experimentation and learning involved in crafting new languages.

Topics discussed in this episode

What inspires the creation of a new programming language
Goals and use cases for a programming language
Influences from Elm, Rust, Haskell, Go, OCaml, and more
Tradeoffs involved in expressiveness of type systems
Opportunistic mutation for performance gains in a functional language
Minimum version selection for dependency resolution
Build time considerations with type checking and monomorphization
Design experiments and rolling back features that don’t work out
History from the first simple interpreter to today's real programming language
Design considerations around package management and versioning
Participation in Advent of Code to gain new users and feedback
Providing performance optimization tools to users in the future
Tradeoffs involved in picking integer types and arithmetic
Comparing floats and equality checks on dictionaries
Using abilities to customize equality for custom types
Ensuring availability of multiple package versions for incremental upgrades
Treating major version bumps as separate artifacts
Roc's focus on single-threaded performance

Links mentioned in this episode

Software Unscripted Podcast https://feeds.resonaterecordings.com/software-unscripted
Roc Programming Language https://www.roc-lang.org/
Roc Lang on Github https://github.com/roc-lang/roc
Elm Programming Language https://elm-lang.org/
Elm in Action by Richard Feldman https://www.manning.com/books/elm-in-action
Richard Feldman on Github https://github.com/rtfeldman
Lua Programming Language https://www.lua.org/
Vimscript Guide https://google.github.io/styleguide/vimscriptfull.xml
OCaml Programming Language https://ocaml.org/
Advent of Code https://adventofcode.com/
Roc Language on Twitter https://twitter.com/roc_lang
Richard Feldman on Twitter https://twitter.com/rtfeldman
Roc Zulip Chat https://roc.zulipchat.com
Clojure Programming Language https://clojure.org/
Talk: Persistent Data Structures and Managed References by Rich Hickey https://www.youtube.com/watch?v=toD45DtVCFM
Koka Programming Language https://koka-lang.github.io/koka/doc/index.html
Flix Programming Language https://flix.dev/
Clojure Transients https://clojure.org/reference/transients
Haskell Software Transactional Memory https://wiki.haskell.org/Software_transactional_memory
Rust Traits https://doc.rust-lang.org/book/ch10-02-traits.html
CoffeeScript https://coffeescript.org/
Cargo Package Management https://doc.rust-lang.org/book/ch01-03-hello-cargo.html
Versioning in Golang https://research.swtch.com/vgo-principles

Special Guests: José Valim and Richard Feldman.

Package Management in Elixir vs. JavaScript with Wojtek Mach & Amal Hussein

podcast@smartlogic.io (SmartLogic LLC) — Thu, 04 Jan 2024 07:00:00 -0500

Today on Elixir Wizards, Wojtek Mach of HexPM and Amal Hussein, engineering leader and former NPM team member, join Owen Bickford to compare notes on package management in Elixir vs. JavaScript. This lively conversation covers everything from best practices for dependency management to API design, SemVer (semantic versioning), and the dark ages of web development before package managers existed.

The guests debate philosophical differences between the JavaScript and Elixir communities. They highlight the JavaScript ecosystem's maturity and identify potential areas of improvement, contrasted against Elixir’s emphasis on minimal dependencies. Both guests encourage engineers to publish packages, even small ones, as a learning opportunity.

Topics discussed in this episode:

Leveraging community packages rather than reinventing the wheel
Vetting packages carefully before adopting them as dependencies
Evaluating security, performance, and bundle size when assessing packages
Managing transitive dependencies pulled in by packages
Why semantic versioning is difficult to consistently enforce
Designing APIs with extensibility and backward compatibility in mind
Using tools like deprecations to avoid breaking changes in new releases
JavaScript’s preference for code reuse over minimization
The Elixir community’s minimal dependencies and avoidance of tech debt
Challenges in early package management, such as global dependency
Learning from tools like Ruby Gems and Bundler to improve experience
How log files provide visibility into dependency management actions
How lock files pin dependency versions for consistency
Publishing packages democratizes access and provides learning opportunities
Linting to enforce standards and prevent certain bugs
Primitive-focused packages provide flexibility over highly opinionated ones
Suggestions for improving documentation and guides
Benefits of collaboration between programming language communities

Links mentioned in this episode:

Node.js https://github.com/nodejs
npm JavaScript Package Manager https://github.com/npm
JS Party Podcast https://changelog.com/jsparty
Dashbit https://dashbit.co/
HexPM Package Manager for Erlang https://hex.pm/
HTTP Client for Elixir https://github.com/wojtekmach/req
Ecto Database-Wrapper for Elixir https://github.com/elixir-ecto (Not an ORM)
XState Actor-Based State Management for JavaScript https://xstate.js.org/docs/
Supply Chain Protection for JavaScript, Python, and Go https://socket.dev/
MixAudit https://github.com/mirego/mix_audit
NimbleTOTP Library for 2FA https://hexdocs.pm/nimble_totp/NimbleTOTP.html
Microsoft Azure https://github.com/Azure
Patch Package https://www.npmjs.com/package/patch-package
Ruby Bundler to manage Gem dependencies https://github.com/rubygems/bundler
npm-shrinkwrap https://docs.npmjs.com/cli/v10/commands/npm-shrinkwrap
SemVer Semantic Versioner for NPM https://www.npmjs.com/package/semver
Spec-ulation Keynote - Rich Hickey https://www.youtube.com/watch?v=oyLBGkS5ICk
Amal’s favorite Linter https://eslint.org/
Elixir Mint Functional HTTP Client for Elixir https://github.com/elixir-mint
Tailwind Open Source CSS Framework https://tailwindcss.com/
WebauthnComponents https://hex.pm/packages/webauthn_components

Special Guests: Amal Hussein and Wojtek Mach.

Communities in Tech with Camille Clayton & Scott Tolinski

podcast@smartlogic.io (SmartLogic LLC) — Thu, 28 Dec 2023 07:00:00 -0500

Today on Elixir Wizards, Camille Clayton, Director of Women Who Code DC, and Scott Tolinski, Co-Host of the Syntax Podcast and Creator of Level Up Tutorials, join hosts Sundi Myint and Owen Bickford to discuss tech community spaces online and IRL.

They lay out the blueprint and best practices for fostering an inclusive environment where newcomers feel comfortable and welcome to join the discussion – whether it’s an online forum, YouTube comment sections, social media platform, local meetup, or conference.

Topics discussed in this episode:

Leaving a space open so newcomers feel empowered to join
Celebrating small wins to maintain excitement and build confidence
Why consistency is key to building a community with longevity
Creating and enforcing a code of conduct to define expectations
Finding respectful resolutions for addressing issues or complaints
The importance of amplifying underrepresented voices in tech
Creating content for all skill levels and adapting to a wider audience
How remote meetups broaden the possibilities for attendance and connection
Finding the right fit for mentorship
Delegation to strengthen community members’ sense of ownership
Navigating the new normal of local, in-person gatherings post-pandemic

Special Guests: Camille Clayton and Scott Tolinski.

Actor Model and Concurrent Processing in Elixir vs. Clojure and Ruby with Xiang Ji & Nathan Hessler

podcast@smartlogic.io (SmartLogic LLC) — Thu, 21 Dec 2023 07:00:00 -0500

In this episode of Elixir Wizards, Xiang Ji and Nathan Hessler join hosts Sundi Myint and Owen Bickford to compare actor model implementation in Elixir, Ruby, and Clojure.

In Elixir, the actor model is core to how the BEAM VM works, with lightweight processes communicating asynchronously via message passing. GenServers provide a common abstraction for building actors, handling messages, and maintaining internal state. In Ruby, the actor model is represented through Ractors, which currently map to OS threads.

They discuss what we can learn by comparing models, understanding tradeoffs between VMs, languages, and concurrency primitives, and how this knowledge can help us choose the best tools for a project.

Topics discussed in this episode:

Difference between actor model and shared memory concurrency
Isolation of actor state and communication via message passing
BEAM VM design for high concurrency via lightweight processes
GenServers as common abstraction for building stateful actors
GenServer callbacks for message handling and state updates
Agents as similar process abstraction to GenServers
Shared state utilities like ETS for inter-process communication
Global Interpreter Lock in older Ruby VMs
Ractors as initial actor implementation in Ruby mapping to threads
Planned improvements to Ruby concurrency in 3.3
Akka implementation of actor model on JVM using thread scheduling
Limitations of shared memory concurrency on JVM
Project Loom bringing lightweight processes to JVM
Building GenServer behavior in Ruby using metaprogramming
CSP model of communication using channels in Clojure
Differences between BEAM scheduler and thread-based VMs
Comparing Elixir to academic languages like Haskell
Remote and theScore are hiring!

Links mentioned in this episode:

theScore is hiring! https://www.thescore.com/
Remote is also hiring! https://remote.com/
Comparing the Actor Model and CSP with Elixir and Clojure Blog Post by Xiang Ji
Comparing the Actor model & CSP concurrency with Elixir & Clojure Xiang Ji at ElixirConf EU 2022
Clojure Programming Language https://clojure.org/
Akka https://akka.io/
Go Programming Language https://github.com/golang/go
Proto Actor for Golang https://proto.actor/
RabbitMQ Open-Source Message Broker Software https://github.com/rabbitmq
JVM Project Loom https://github.com/openjdk/loom
Ractor for Ruby https://docs.ruby-lang.org/en/master/ractor_md.html
Seven Concurrency Models in Seven Weeks: When Threads Unravel by Paul Butcher
Seven Languages in Seven Weeks by Bruce A. Tate
GenServer https://hexdocs.pm/elixir/1.12/GenServer.html
ets https://www.erlang.org/doc/man/ets.html
Elixir in Action by Saša Jurić
Redis https://github.com/redis/redis
Designing for Scalability with Erlang/OTP by Francesco Cesarini & Steve Vinoski
Discord Blog: Using Rust to Scale Elixir for 11 Million Concurrent Users
Xiang's website https://xiangji.me/
Feeling Good: The New Mood Therapy by David D. Burns

Special Guests: Nathan Hessler and Xiang Ji.

Static Code Analysis in Elixir vs. Ruby with René Föhring & Marc-André Lafortune

podcast@smartlogic.io (SmartLogic LLC) — Thu, 14 Dec 2023 07:00:00 -0500

In this episode of Elixir Wizards, hosts Owen and Dan are joined by René Föhring, creator of Credo for Elixir, and Marc-André LaFortune, head maintainer of the RuboCop AST library for Ruby. They compare static code analysis in Ruby versus Elixir.

The conversation explores the intricacies and challenges inherent in static code analysis across object-oriented and functional programming paradigms, highlighting the unique characteristics of both Ruby and Elixir. Key topics of discussion include the ways these tools can enhance coding styles and empower developers, the delicate balance between providing guidance and enforcing rules, and the evolving future of code analysis in these languages.

Topics discussed in this episode:

The differences and applications between static and dynamic analysis
How Credo aims to offer flexible and educational guidance for Elixir developers
The complexities of method identification in Ruby and its impact on static analysis
Challenges posed by macros and dynamic code modification during compilation in Elixir
Reducing false positives in code analysis tools to minimize developer frustration
Promoting uniform coding practices through analysis tools
The significance of using analysis tools with clear, specific objectives
How coding standards can refine and improve coding styles over time
Building analysis tools and checks through an understanding of Abstract Syntax Trees (ASTs)
Potential advancements in the analysis of Phoenix templates and HTML in Elixir
Contrasting approaches to managing code and comments in Elixir and Ruby ASTs
The fine line between providing helpful guidance and imposing stylistic preferences
Heuristics in static analysis highlight inconsistencies without mandating style
The potential for more straightforward pattern matching in ASTs with future updates
The importance of a gradual implementation of tool updates to maintain backward compatibility
Creating tools that support and empower developers, rather than hinder them
How static analysis contributes to cleaner, more maintainable codebases
Potential future developments in the field of static code analysis
Practical applications of using linters like Credo and RuboCop in software development

Links mentioned in this episode:

Credo https://github.com/rrrene/credo
https://hexdocs.pm/credo/overview.html
Dogma: A code style linter for Elixir https://github.com/lpil/dogma
https://github.com/rubocop/rubocop
RuboCop's AST extensions and NodePattern functionality https://github.com/rubocop/rubocop-ast
https://github.com/whitequark/parser
https://hex.pm/packages?search=credo&sort=recent_downloads
https://github.com/doorgan/sourceror
https://github.com/rrrene/credo/blob/master/lib/credo/check/readability/large_numbers.ex

Special Guests: Marc-André Lafortune and René Föhring.

Web Development Frameworks: Elixir and Phoenix vs. Ruby on Rails with Owen Bickford & Dan Ivovich

podcast@smartlogic.io (SmartLogic LLC) — Thu, 07 Dec 2023 07:00:00 -0500

On today’s episode, Elixir Wizards Owen Bickford and Dan Ivovich compare notes on building web applications with Elixir and the Phoenix Framework versus Ruby on Rails. They discuss the history of both frameworks, key differences in architecture and approach, and deciding which programming language to use when starting a project.

Both Phoenix and Rails are robust frameworks that enable developers to build high-quality web apps—Phoenix leverages functional programming in Elixir and Erlang’s networking for real-time communication. Rails follows object-oriented principles and has a vast ecosystem of plug-ins. For data-heavy CRUD apps, Phoenix's immutable data pipelines provide some advantages.

Developers can build great web apps with either Phoenix or Rails. Phoenix may have a slight edge for new projects based on its functional approach, built-in real-time features like LiveView, and ability to scale efficiently. But, choosing the right tech stack depends heavily on the app's specific requirements and the team's existing skills.

Topics discussed in this episode:

History and evolution of Phoenix Framework and Ruby on Rails
Default project structure and code organization preferences in each framework
Comparing object-oriented vs functional programming paradigms
CRUD app development and interaction with databases
Live reloading capabilities in Phoenix LiveView vs Rails Turbolinks
Leveraging WebSockets for real-time UI updates
Testing frameworks like RSpec, Cucumber, Wallaby, and Capybara
Dependency management and size of standard libraries
Scalability and distribution across nodes
Readability and approachability of object-oriented code
Immutability and data pipelines in functional programming
Types, specs, and static analysis with Dialyzer
Monkey patching in Ruby vs extensible core language in Elixir
Factors to consider when choosing between frameworks
Experience training new developers on Phoenix and Rails
Community influences on coding styles
Real-world project examples and refactoring approaches
Deployment and dev ops differences
Popularity and adoption curves of both frameworks
Ongoing research into improving Phoenix and Rails

Links Mentioned in this Episode:

SmartLogic.io
Dan’s LinkedIn
Owen’s LinkedIn
Ruby https://www.ruby-lang.org/en/
Rails https://rubyonrails.org/
Sams Teach Yourself Ruby in 21 Days
Learn Ruby in 7 Days
Build Your Own Ruby on Rails Web Applications
Django https://github.com/django
Sidekiq https://github.com/sidekiq
Kafka https://kafka.apache.org/
Phoenix Framework https://www.phoenixframework.org/
Phoenix LiveView https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html#content
Flask https://flask.palletsprojects.com/en/3.0.x/
WebSockets API https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API
WebSocket connection for Phoenix https://github.com/phoenixframework/websock
Morph Dom https://github.com/patrick-steele-idem/morphdom
Turbolinks https://github.com/turbolinks
Ecto https://github.com/elixir-ecto
Capybara Testing Framework https://teamcapybara.github.io/capybara/
Wallaby Testing Framework https://wallabyjs.com/
Cucumber Testing Framework https://cucumber.io/
RSpec https://rspec.info/

Garbage Collection in Erlang vs JVM/Akka with Manuel Rubio & Dan Plyukhin

podcast@smartlogic.io (SmartLogic LLC) — Thu, 30 Nov 2023 07:00:00 -0500

Today on Elixir Wizards, Manuel Rubio, author of Erlang/OTP: A Concurrent World and Dan Plyukhin, creator of the UIGC Actor Garbage Collector for Akka, join host Dan Ivovich to compare notes on garbage collection in actor models.

The discussion digs into the similarities and differences of actor-based garbage collection in Erlang and Akka and introduces Dan's research on how to perform garbage collection in a distributed actor system.

Topics discussed:

Akka is akin to Erlang actors for the JVM using Scala, with similar principles like supervision trees, messages, and clustering
Erlang uses generational garbage collection and periodically copies live data to the old heap for long-lived elements
Actor GC aims to determine when an actor's memory can be reclaimed automatically rather than manually killing actors
Distributed actor GC is more challenging than object GC due to the distributed nature and relationships between actors across nodes
Challenges include reasoning about failures like dropped messages and crashed nodes
GC balance requires optimization of resource release and CPU load management
Immutability helps Erlang GC, but copying data for messages impacts performance
Research into distributed actor GC is still ongoing, with opportunities for improvement
Fault tolerance in Erlang relies on user implementation rather than low-level guarantees
Asynchronous messages in Erlang/Elixir mean references may become invalid which is similar to the distributed GC approaches in Dan's research
Idempotent messaging is recommended to handle possible duplicates from failures
Help your local researcher! Researchers encourage communication from practitioners on challenges and use cases

Links mentioned:

Erlang/OTP Volume 1: A Concurrent World by Manuel Rubio https://altenwald.com/en/book/en-erlang-i
Scala https://www.scala-lang.org/
Akka Framework https://github.com/akka
JVM (Java Virtual Machine) https://www.java.com/en/download/
The BEAM VM https://www.erlang.org/blog/a-brief-beam-primer/
Hadoop Framework https://hadoop.apache.org/
Pony Programming Language https://www.ponylang.io/
SLSA Programming Language https://wcl.cs.rpi.edu/salsa/#:~:text=SALSA%20
Paxos Algorithm https://en.wikipedia.org/wiki/Paxos_(computer_science)
Raft library for maintaining a replicated state machine https://github.com/etcd-io/raft
Dan's Website https://dplyukhin.github.io/
Dan Plyukhin on Twitter: https://twitter.com/dplyukhin
Dan Plyukhin’s YouTube channel: https://m.youtube.com/@dplyukhin
UIGC on GitHub https://github.com/dplyukhin/UIGC
Manuel's Website https://altenwald.com/
Manuel Rubio on Twitter: https://twitter.com/MRonErlang

Special Guests: Dan Plyukhin and Manuel Rubio.

Machine Learning in Elixir vs. Python, SQL, and Matlab with Katelynn Burns & Alexis Carpenter

podcast@smartlogic.io (SmartLogic LLC) — Thu, 23 Nov 2023 07:00:00 -0500

In this episode of Elixir Wizards, Katelynn Burns, software engineer at LaunchScout, and Alexis Carpenter, senior data scientist at cars.com, join Host Dan Ivovich to discuss machine learning with Elixir, Python, SQL, and MATLAB. They compare notes on available tools, preprocessing, working with pre-trained models, and training models for specific jobs.

The discussion inspires collaboration and learning across communities while revealing the foundational aspects of ML, such as understanding data and asking the right questions to solve problems effectively.

Topics discussed:

Using pre-trained models in Bumblebee for Elixir projects
Training models using Python and SQL
The importance of data preprocessing before building models
Popular tools used for machine learning in different languages
Getting started with ML by picking a personal project topic of interest
Resources for ML aspirants, such as online courses, tutorials, and books
The potential for Elixir to train more customized models in the future
Similarities between ML approaches in different languages
Collaboration opportunities across programming communities
Choosing the right ML approach for the problem you're trying to solve
Productionalizing models like fine-tuned LLM's
The need for hands-on practice for learning ML skills
Continued maturation of tools like Bumblebee in Elixir
Katelynn's upcoming CodeBeam talk on advanced motion tracking

Links mentioned in this episode

https://launchscout.com/
https://www.cars.com/
Genetic Algorithms in Elixir by Sean Moriarity
Machine Learning in Elixir by Sean Moriarity
https://github.com/elixir-nx/bumblebee
https://github.com/huggingface
https://www.docker.com/products/docker-hub/
Programming with MATLAB
https://elixirforum.com/
https://pypi.org/project/pyspark/
Machine Learning Course from Stanford School of Engineering
Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow by Aurélien Géron
Data Science for Business by Foster Provost & Tom Fawcett
https://medium.com/@carscomtech
https://github.com/k-burns
Code Beam America March, 2024

Special Guests: Alexis Carpenter and Katelynn Burns.

Embedded Systems in Elixir vs. C, C++, and Java with Connor Rigby & Taylor Barto

podcast@smartlogic.io (SmartLogic LLC) — Thu, 16 Nov 2023 07:00:00 -0500

This week on Elixir Wizards, Connor Rigby, Software Engineer at SmartRent, and Taylor Barto, Lead Embedded Software Engineer at Eaton, join Sundi Myint to compare notes on embedded systems development with Elixir, C, C++, and Java. They discuss using Elixir and the Nerves framework for firmware projects versus more traditional choices like C. The guests ask one another questions and gain valuable insights into challenges, tooling, resources, and more across different embedded ecosystems.

In this episode, the guests expand their perspectives and demystify the concept of embedded systems for engineers outside the field. This cross-language exchange of ideas and experiences inspires continued learning and collaboration between embedded software engineers using different programming languages.

Topics Discussed:

Defining "true embedded": using an operating system vs. bare metal programming
Benefits and drawbacks of Elixir, C, C++, and Java for firmware
Many embedded systems today use Java as the programming language via Java Native Interface (JNI) to interface with C/C++ code
How Elixir expands the toolbox available for firmware projects
Testing, tooling, workflows, and debugging across languages
Elixir/Nerves features like hot code reloading and testing vs. Java alternatives
Learning curves for new languages and frameworks
Industry trends around established vs emerging tools
Applying functional programming principles like immutability in new domains
Scaling firmware updates across large connected networks
Continued maturation of Nerves may bring Elixir into consideration for roles where Java is commonly used today
Hardening systems for reliability in safety-critical uses
Debugging differences between web development and embedded
Hiring considerations for niche languages
Additional skills needed for embedded engineers, such as technical writing, reading schematics, and writing test instructions
Resources and recommendations for getting started with embedded systems

Links Mentioned:

Nerves: https://github.com/nerves-project/nerves
https://nerves-project.org/
AtomVM: https://github.com/atomvm/AtomVM
GRiSP: https://github.com/grisp
RISC-V: https://github.com/ultraembedded/riscv
https://smartrent.com/
https://www.eaton.com/us/en-us.html
Zig Programming Language: https://github.com/ziglang
Docker: https://github.com/docker
Build a Weather Station with Elixir and Nerves by Alexander Koutmos, Bruce A. Tate, Frank Hunleth
Build a Binary Clock with Elixir and Nerves by Frank Hunleth and Bruce A. Tate
http://esp32.net/
https://www.nordicsemi.com/

Special Guests: Connor Rigby and Taylor Barto.

ECS / Game Development with Elixir vs. Python, JavaScript, React with Dorian Iacobescu & Daniel Luu

podcast@smartlogic.io (SmartLogic LLC) — Thu, 09 Nov 2023 07:00:00 -0500

In Episode 4, the Elixir Wizards are joined by Dorian Iacobescu, author of the ECSpanse ECS library for Elixir, and Daniel Luu, founder and CEO of the game development studio AKREW. The guests compare notes on backend game development using ECS, the Entity Component System approach.

Akrew is currently building the multiplayer game Galactic Getaway using the Photon Unity networking framework, which employs ECS. They discuss challenges like collections of component types and persistence beyond runtime, building games for various platforms like MacOS, and handling inventory storage in a backend database.

Game development is complex and has many technical hurdles, but open communication across different programming communities and game development approaches can foster collaboration, innovation, and continued learning.

Topics Discussed in this Episode

Dorian explains the ECSpanse ECS library and component-based architecture
Dorian took inspiration for ECSpanse from the Rust library Bevy ECS and its component-based API
The guests discuss popular game development platforms and languages, including C#, JavaScript, and Godot
Owen and Daniel translate ECS concepts to familiar database and backend terminology for devs without game-specific experience
ECSpanse uses many tools from the Elixir Erlang toolbox, including GenServers, ETS tables, tasks, queries, and Phoenix LiveView
ECS challenges representing inventory collections that broke typical ECS singleton patterns
AKREW is developing Galactic Getaway using the Photon Unity framework
Relationships between parent and child entities in ECSpanse
Persistence, serialization, and replay features to save game state
Optimizing assets and code for performance on various devices

Links Mentioned

https://en.wikipedia.org/wiki/Entity_component_system
https://iacobson.medium.com/elixir-for-fun-ecspanse-2852a7993ecd
https://hexdocs.pm/ecspanse/Ecspanse.html
https://bevyengine.org/learn/book/getting-started/ecs/
https://www.photonengine.com/quantum
Add Galactic Getaway to your Steam Wishlist: https://store.steampowered.com/app/2012390/Galactic_Getaway/
https://godotengine.org/
https://unity.com/
https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_basics.html
https://www.tiktok.com/@galacticgetaway
https://docs.rs/bevy_ecs/latest/bevy_ecs/

Special Guests: Daniel Luu and Dorian Iacobescu.

Learning a Language: Elixir vs. JavaScript with Yohana Tesfazgi & Wes Bos

podcast@smartlogic.io (SmartLogic LLC) — Thu, 02 Nov 2023 07:00:00 -0400

This week, the Elixir Wizards are joined by Yohana Tesfazgi and Wes Bos to compare notes on the experience of learning Elixir vs. JavaScript as your first programming language. Yohana recently completed an Elixir apprenticeship, and Wes Bos is a renowned JavaScript educator with popular courses for beginner software developers.

They discuss a variety of media and resources and how people with different learning styles benefit from video courses, articles, or more hands-on projects. They also discuss the current atmosphere for those looking to transition into an engineering career and how to stick out among the crowd when new to the scene.

Topics Discussed in this Episode

Pros and cons of learning Elixir as your first programming language
Materials and resources for beginners to JavaScript and Elixir
Projects and methods for learning Elixir with no prior knowledge
Recommendations for sharpening and showcasing skills
How to become a standout candidate for potential employers
Soft skills like communication translate well from other careers to programming work
Learning subsequent languages becomes more intuitive once you learn your first
How to decide which library to use for a project
How to build an online presence and why it’s important
Open-source contributions are a way to learn from the community
Ship early and often, just deploying a default Phoenix app teaches deployment skills
Attend local meetups and conferences for mentoring and potential job opportunities

HTTP Requests in Elixir vs. JavaScript with Yordis Prieto & Stephen Chudleigh

podcast@smartlogic.io (SmartLogic LLC) — Thu, 26 Oct 2023 07:00:00 -0400

In today’s episode, Sundi and Owen are joined by Yordis Prieto and Stephen Chudleigh to compare notes on HTTP requests in Elixir vs. Ruby, JavaScript, Go, and Rust. They cover common pain points when working with APIs, best practices, and lessons that can be learned from other programming languages.

Yordis maintains Elixir's popular Tesla HTTP client library and shares insights from building APIs and maintaining open-source projects. Stephen has experience with Rails and JavaScript, and now works primarily in Elixir. They offer perspectives on testing HTTP requests and working with different libraries.

While Elixir has matured, there is room for improvement - especially around richer struct parsing from HTTP responses. The discussion highlights ongoing efforts to improve the developer experience for HTTP clients in Elixir and other ecosystems.

Topics Discussed in this Episode

HTTP is a protocol - but each language has different implementation methods
Tesla represents requests as middleware that can be modified before sending
Testing HTTP requests can be a challenge due to dependence on outside systems
GraphQL, OpenAPI, and JSON API provide clear request/response formats
Elixir could improve richer parsing from HTTP into structs
Focus on contribution ergonomics lowers barriers for new participants
Maintainers emphasize making contributions easy via templates and clear documentation
APIs drive adoption of standards for client/server contracts
They discuss GraphQL, JSON API, OpenAPI schemas, and other standards that provide clear request/response formats
TypeScript brings types to APIs and helps to validate responses
Yordis notes that Go and Rust make requests simple via tags for mapping JSON to structs
Language collaboration shares strengths from different ecosystems and inspires new libraries and tools for improving the programming experience

Links Mentioned

Special Guests: Stephen Chudleigh and Yordis Prieto.

Season 11 Kickoff: The Hosts Discuss Branching Out from Elixir to Compare Notes

podcast@smartlogic.io (SmartLogic LLC) — Thu, 19 Oct 2023 07:00:00 -0400

Hosts Dan Ivovich, Owen Bickford, and Sundi Myint kick off the 11th season of the Elixir Wizards podcast. This season’s theme is “Branching Out from Elixir,” which expands the conversation to compare notes with experts from other communities; they discuss their experiences with other languages like JavaScript, PHP, Python, Ruby, C#, Go, and Dart before and after learning Elixir.

This season's conversations will illuminate how problems are solved in different languages vs. Elixir; upcoming episode topics teased include education, data processing, deployment strategies, and garbage collection; the hosts express excitement for conversations analyzing similarities and differences between communities.

Topics Discussed in this Episode

Season 11 branches out from Elixir to compare notes with other programming communities
Sundi, Owen, and Dan introduce the season theme and their interest in exploring these conversations
The hosts compare their experiences with PHP, JavaScript, Python, Ruby, C#, Go, Dart and Elixir
The Wizards compare and contrast differences in their personal experience building similar things with different languages
Dan dreams in Ruby and uses it for quick prototypes
Comparing problem-solving approaches across languages will reframe perspectives
Upcoming episodes explore data processing workflows, machine learning, and game development
Pop Quiz: Who's that Pokémon... or language, or framework?

Links Mentioned

https://smartlogic.io/
https://codepen.io/
https://i.redd.it/0lg7979qtr511.jpg

José Valim, Guillaume Duboc, and Giuseppe Castagna on the Future of Types in Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 08 Jun 2023 06:00:00 -0400

It’s the Season 10 finale of the Elixir Wizards podcast! José Valim, Guillaume Duboc, and Giuseppe Castagna join Wizards Owen Bickford and Dan Ivovich to dive into the prospect of types in the Elixir programming language! They break down their research on set-theoretical typing and highlight their goal of creating a type system that supports as many Elixir idioms as possible while balancing simplicity and pragmatism.

José, Guillaume, and Giuseppe talk about what initially sparked this project, the challenges in bringing types to Elixir, and the benefits that the Elixir community can expect from this exciting work. Guillaume's formalization and Giuseppe's "cutting-edge research" balance José's pragmatism and "Guardian of Orthodoxy" role. Decades of theory meet the needs of a living language, with open challenges like multi-process typing ahead. They come together with a shared joy of problem-solving that will accelerate Elixir's continued growth.

Key Topics Discussed in this Episode:

Adding type safety to Elixir through set theoretical typing
How the team chose a type system that supports as many Elixir idioms as possible
Balancing simplicity and pragmatism in type system design
Addressing challenges like typing maps, pattern matching, and guards
The tradeoffs between Dialyzer and making types part of the core language
Advantages of typing for catching bugs, documentation, and tooling
The differences between typing in the Gleam programming language vs. Elixir
The possibility of type inference in a set-theoretic type system
The history and development of set-theoretic types over 20 years
Gradual typing techniques for integrating typed and untyped code
How José and Giuseppe initially connected through research papers
Using types as a form of "mechanized documentation"
The risks and tradeoffs of choosing syntax
Cheers to another decade of Elixir!
A big thanks to this season’s guests and all the listeners!

Links and Resources Mentioned in this Episode:

Bringing Types to Elixir | Guillaume Duboc & Giuseppe Castagna | ElixirConf EU 2023
Keynote: Celebrating the 10 Years of Elixir | José Valim | ElixirConf EU 2022
OCaml industrial-strength functional programming https://ocaml.org/
ℂDuce: a language for transformation of XML documents http://www.cduce.org/
Ballerina coding language https://ballerina.io/
Luau coding language https://luau-lang.org/
Gleam type language https://gleam.run/
"The Design Principles of the Elixir Type System" by G. Castagna, G. Duboc, and J. Valim
"A Gradual Type System for Elixir" by M. Cassola, A. Talagorria, A. Pardo, and M. Viera
"Programming with union, intersection, and negation types", by Giuseppe Castagna
"Covariance and Contravariance: a fresh look at an old issue (a primer in advanced type systems for learning functional programmers)" by Giuseppe Castagna
"A reckless introduction to Hindley-Milner type inference"

Special Guests: Giuseppe Castagna, Guillaume Duboc, and José Valim.

Chris McCord and Jason Stiebs on the Future of Phoenix

podcast@smartlogic.io (SmartLogic LLC) — Thu, 01 Jun 2023 06:00:00 -0400

Phoenix core team members Chris McCord and Jason Stiebs join Elixir Wizards Sundi Myint and Owen Bickford the growth of Phoenix and LiveView, the latest updates, and what they're excited to see in the future. They express excitement for the possibilities of machine learning, AI, and distributed systems and how these emerging technologies will enhance the user experience of Elixir and LiveView applications in the next decade.

Key Topics Discussed in this Episode:

How community contributions and feedback help improve Phoenix LiveView
The addition of function components, declarative assigns, HEEx, and streams
Why Ecto changesets should be used as "fire and forget" data structures
Excitement about machine learning and AI with libraries like NX
The possibility of distributed systems and actors in the future
Verifying and solving issues in the Phoenix and LiveView issue trackers
Why marketing plays a part in the adoption and mindshare of Phoenix
How streams provide a primitive for arbitrarily large dynamic lists
Elixir VM's ability to scale to millions of connections
A creative use of form inputs for associations with dynamic children

Links Mentioned in this Episode:

Fly Site https://fly.io/
Keynote: The Road To LiveView 1.0 by Chris McCord | ElixirConf EU 2023
Keynote: I Was Wrong About LiveView by Jason Stiebs | ElixirConf 2022
Phoenix Site https://www.phoenixframework.org/
Phoenix Github https://github.com/phoenixframework
Two-Story, 10-Room Purple Martin House
Blog: The Road to 2 Million Websocket Connections in Phoenix
Raxx Elixir Webserver Interface https://hexdocs.pm/raxx/0.4.1/readme.html
Livebook Site https://livebook.dev/
Sundi’s 6’x 6’ Phoenix painting
Surface on Hex https://hex.pm/packages/surface
Axon Deep Learning Framework https://hexdocs.pm/axon/Axon.html
Nx Numerical Elixir https://hexdocs.pm/nx/intro-to-nx.html
Phoenix PubSub https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html
Jason Stiebs on Twitter https://twitter.com/peregrine
Jason Stiebs on Mastodon https://merveilles.town/@peregrine

Special Guests: Chris McCord and Jason Stiebs.

Sean Moriarity on the Future of Machine Learning with Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 25 May 2023 06:00:00 -0400

Sean Moriarity, author of Genetic Algorithms in Elixir and creator of the Axon Library, joins Elixir Wizards Sundi Myint and Bilal Hankins to discuss Elixir’s role in the future of machine learning and AI. He explains the difference between artificial intelligence, chat models, machine learning, deep learning systems, and neural networks.

Large language models have great potential for code generation, education tools, streamlining workflow, and more. Deployment, development experience, and real-time processing make Elixir an ideal programming language for creating and improving machine learning tools.

Key Topics Discussed in this Episode:

The difference between machine learning and artificial intelligence
How Axon builds on top of the Nx library for deep learning in Elixir
Why logic cannot fully define characteristics that identify golden retrievers
How Google Translate uses machine learning with a unified language model
The difficulties in translating concepts with no direct counterpart between languages
Data cleaning and labeling challenges
How Sean's interest in sports betting led to exploring machine learning
Why Sean's NBA betting model recommended betting $0 to maximize profit
Getting started with machine learning and Elixir projects
Attention mechanisms in neural networks
Bias and exceptions in machine translation models
How hummus preference was used to determine Sundi's Hogwarts house
Sean's work on a LiveView interface for ChatGPT
Why Elixir's deployment story, development experience, and real-time processing are good fits for machine learning applications

Links Mentioned:

Genetic Algorithms in Elixir by Sean Moriarity: https://pragprog.com/titles/smgaelixir/genetic-algorithms-in-elixir/
Axon Deep Learning in Elixir: https://seanmoriarity.com/2021/04/08/axon-deep-learning-in-elixir/
Nx Axon: https://github.com/elixir-nx/axon
Sean’s Twitter: https://twitter.com/sean_moriarity
Weston the Golden’s IG: https://www.instagram.com/westonthegolden_/
Sean’s Github: https://github.com/seanmor5
Bumblebee: https://github.com/elixir-nx/bumblebee
Sal Khan’s TedTalk about AI in Education: https://www.ted.com/talks/sal_khan_how_ai_could_save_not_destroy_education/c
Publicly Available Datasets/Intro to Machine Learning: https://www.kaggle.com/
Use code WIZARD for $100 off your ticket to Empex NYC in Brooklyn, NY on June 9, 2023 https://ti.to/empex-ny/empex-nyc-2023

Special Guest: Sean Moriarity.

Hugo Baraúna & Lucas San Roman on the Future of the Elixir Community

podcast@smartlogic.io (SmartLogic LLC) — Thu, 18 May 2023 06:00:00 -0400

In this episode of the Elixir Wizards podcast, hosts Sundi Myint and Owen Bickford are joined by Hugo Baraúna, founder at Elixir Radar, and Lucas San Roman, senior software engineer at Felt. We dive into the future of the Elixir community, how we stay connected, and the remarkable culture that has developed over the past decade.

Key highlights in this episode:

The Elixir community's warm and inviting atmosphere
Commitment to long-term stability and innovation in the Elixir community
How projects like Nerves, Phoenix LiveView, and Livebook expand Elixir's capabilities
Global connections and support among Elixirists via Slack and Discord
The Elixir Radar newsletter provides up-to-date Elixir news and community developments
Getting “nerd sniped” by the community
Hugo Baraúna's motivation behind Elixir Radar and its impact on the tech industry
Networking opportunities and relationship-building within the community
Lucas San Roman's commitment to giving back with the Sourcerer Library
Plans for more advanced collaboration in Livebook with the new Teams feature
The potential introduction of a type system in Elixir

Links mentioned in this episode:

Elixir Radar: https://elixir-radar.com/
Felt: https://felt.com/
Ruby Weekly: https://rubyweekly.com/
The Elixir Discord Server: https://discord.com/invite/elixir
Code Fragment: https://hexdocs.pm/elixir/Code.Fragment.html
The Sourcerer Library: https://github.com/doorgan/sourceror
Livebook: https://livebook.dev/
Lucas’ Blog: https://dorgan.ar/
Hugo’s Twitter: https://twitter.com/hugobarauna
Elixir Radar on Twitter: https://twitter.com/elixir_radar
Livebook on Twitter: https://twitter.com/livebookdev
Lucas’ Twitter https://twitter.com/dorgan_
Guillaume Duboc Bringing Types to Elixir at ElixirConf EU 2023
Lucas on GitHub: https://github.com/doorgan
Rooster Fighter on Easter Island
Rooster Fighter at Iguazu Falls in Argentina

Use code WIZARD for $100 off your ticket to Empex NYC in Brooklyn, NY on June 9, 2023

Special Guests: Hugo Baraúna and Lucas San Roman.

José Valim on the Future of the Elixir Ecosystem

podcast@smartlogic.io (SmartLogic LLC) — Thu, 11 May 2023 06:00:00 -0400

Today on Elixir Wizards, José Valim, creator of the Elixir programming language, joins hosts Sundi Myint and Owen Bickford to discuss the future of Elixir, upcoming features, changes to the language and ecosystem, and the potential for a type system.

José discusses how Elixir’s extensibility allows the ecosystem to grow with new tools and libraries, all while requiring few languages to the core language.

Key Takeaways:

The origin of the famous rainbow heart combo
José’s hands-off approach to planning the ecosystem which allows community contribution without reliance on the core team
The success and growth of the Elixir community
Lessons learned in the first ten years of the language
The evolution of Elixir's documentation and the role of Livebook in creating more interactive and engaging learning experiences
The potential for Elixir Nx to make numerical computation, machine learning, and data science more accessible to Elixir developers
Potential implementation of a gradual type system and the importance of backwards compatibility
The role of the Elixir community in shaping the language's development and ecosystem, including the importance of open-source contributions
Whether we’ll see Elixir 2.0 in the next decade

Links mentioned in this episode:

Josė Valim Keynote ElixirConf EU Bringing Elixir to Life
Dashbit - https://dashbit.co/
Elixir programming language: https://elixir-lang.org/
ElixirConf: https://elixirconf.com/
ElixirForum: https://elixirforum.com/
Elixir's Logger library: https://hexdocs.pm/logger/Logger.html
José's Twitter: https://twitter.com/josevalim
ElixirLS (Elixir Language Server) https://github.com/elixir-lsp/elixir-ls
Mermaid Charts in Livebook - https://news.livebook.dev/date/2022/1
IEx - https://hexdocs.pm/iex/1.14/IEx.html
Numerical Elixir - Nx: https://hexdocs.pm/nx/getting-started.html
Nerves: https://hexdocs.pm/nerves/getting-started.html
Membrane: https://hexdocs.pm/membrane/getting-started.html
Dialyxir: https://hexdocs.pm/dialyxir/readme.html
LiveBook: https://hexdocs.pm/livebook/getting-started.html
Bumblebee: https://github.com/elixir-nx/bumblebee

Special Guest: José Valim.

Saša Jurić on The Future of Training & Education in Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 04 May 2023 06:00:00 -0400

Today on Elixir Wizards, Sundi Myint and Owen Bickford are joined by Saša Jurić, distinguished developer, mentor, and author of Elixir in Action. They discuss the future of training and education in Elixir, challenges faced by new Elixir developers, Phoenix generators, peer mentorship, the emergence of types, and when it’s time to close the umbrella.

Key Takeaways:

The functional programming paradigm, the actor model, and concurrency
Adapting to the Elixir syntax and tooling
The role of community, mentorship, and continuous learning in Elixir education
The pros and cons of Phoenix generators for Elixir development
Customizing templates in the Phoenix priv directory to better suit individual needs
The importance of understanding and adapting generated code for maintainability and proper abstractions
Importance of having a clear separation between core and interface
Adapting to different opinions and preferences within a development team
Refactoring and restructuring code to improve quality and reduce complexity
Static typing for better documentation and the limitations of dynamic code
Umbrella apps vs. mix configuration and how to avoid complexity

Links Mentioned in this Episode:

Enter to win a copy of Elixir in Action: https://smr.tl/2023bookgiveaway

Elixir in Action by Saša Jurić https://www.manning.com/books/elixir-in-action
35% discount code for book on manning.com: podexwizards20

Saša’s Website/Blog TheErlangelist.com
Towards Maintainable Elixir - Saša Jurić's Medium Blog Article Series
Boundary: Managing cross-module dependencies in Elixir projects
Site Encrypt: Integrated Certification via Let's Encrypt for Elixir-powered sites

Authentication Generator in Phoenix: https://hexdocs.pm/phoenix/mix_phx_gen_auth.html
Ecto query generator for Elixir https://hexdocs.pm/ecto/Ecto.html
GraphQL: Query language for APIs https://graphql.org/
Dialyxir: https://hexdocs.pm/dialyxir/readme.html
Nx (Numerical Elixir) GitHub Repository: https://github.com/elixir-nx/nx
ElixirLS (Elixir Language Server) GitHub Repository: https://github.com/elixir-lsp/elixir-ls

Special Guest: Saša Jurić.

Mat Trudel on the Future of Phoenix and Web Transports

podcast@smartlogic.io (SmartLogic LLC) — Thu, 27 Apr 2023 07:15:00 -0400

In this episode of Elixir Wizards, Owen and Dan talk to Mat Trudel, Phoenix contributor and creator of the Bandit Web Server, about the future of Phoenix, web transports, and HTTP/3. Mat explains the challenges and benefits of implementing HTTP/3 support in Phoenix.

Mat provides in-depth insights into the evolution of web protocols and encourages developers to continue pushing the boundaries of web development and to contribute to the growth of the open-source community.

Main topics discussed in this episode:

The evolution of web protocols and how HTTP/3 is changing the landscape
The challenges and benefits of implementing HTTP/3 support in Phoenix
How a home AC project revealed a gap in web server testing tools and inspired Bandit
how web transports like Cowboy and Ranch are used to build scalable web servers
WebSock for multiplexing data over a single WebSocket connection
Mat’s philosophy on naming projects and his passion for malapropisms
The Bandit project and how it can help developers better understand web protocols
Autobahn, a testing suite for WebSocket protocol specification conformance
The importance of community involvement in open-source projects
Encouragement for more people to use Bandit and report bugs

Links Mentioned:

SmartLogic is Hiring: https://smartlogic.io/about/jobs
PagerDuty: https://www.pagerduty.com
Phoenix Framework: https://www.phoenixframework.org/
Cowboy: https://ninenines.eu/docs/en/cowboy/2.9/guide/introduction/
Ranch: https://github.com/ninenines/ranch
Bandit - https://hexdocs.pm/bandit/Bandit.html
Autobahn: https://github.com/crossbario/autobahn-testsuite
HTTP Cats: https://http.cat/
Mat Trudel at Empex 2022 A Funny Thing Happened On The Way To The Phoenix
Thousand Island - https://hexdocs.pm/thousand_island/ThousandIsland.html

Special Guest: Mat Trudel.

Mike Waud and Tony Winn on the Future of Elixir on the Grid

podcast@smartlogic.io (SmartLogic LLC) — Thu, 20 Apr 2023 06:00:00 -0400

Elixir Wizards Owen Bickford and Dan Ivovich are joined by Mike Waud, Senior Software Engineer at SparkMeter, and Tony Winn, Lead Software Architect at Generac, to discuss the future of the BEAM in the electric grid, how their companies use Elixir, and the challenges they face in implementing cutting-edge technologies in an environment with a mix of old and new systems.

Both guests have backgrounds in various programming languages before turning to Elixir for its functional programming capabilities, concurrency, and reliability. Elixir's portability allows it to be used in various environments, from cloud-based systems to more conservative organizations that prefer running software off the cloud.

Key topics discussed in this episode:

• Technology sophistication varies across different regions and industries
• BEAM's reliability, concurrency, and scaling in electric grid systems
• Using Elixir for caching, telemetry, and managing traffic spikes
• Elixir fits well for devices due to its fault tolerance and supervision trees
• Observability with telemetry hooks for understanding system performance
• Traffic patterns in the grid space are often dictated by weather and human activity, requiring efficient handling
• The balance between using Elixir/BEAM and other tools depending on use case
• Using Elixir tools like Broadway to work with event queues and Nebulex for distributed caching
• The future of the electric grid and its evolution over the next 10 years, including a shift towards more distributed energy generation
• Global lessons about grid management, solar penetration, regulations, and energy storage
• Prioritizing data in IoT systems and processing data at the edge of the network
• Gratitude for open-source contributors in the Elixir community

Links in this episode:

SparkMeter: https://www.sparkmeter.io/
Generac: https://www.generac.com/
SmartLogic - https://smartlogic.io/jobs
Gary Bernhardt's talk on functional core and imperative shell: https://www.destroyallsoftware.com/talks/boundaries
Joe Armstrong's Erlang book: https://pragprog.com/titles/jaerlang/programming-erlang/
The Nerves podcast and documentation: https://nerves-project.org/

Special Guests: Mike Waud and Tony Winn.

Sophie DeBenedetto on the Future of Elixir and LiveView

podcast@smartlogic.io (SmartLogic LLC) — Thu, 13 Apr 2023 06:00:00 -0400

In today's episode, Sophie DeBenedetto emphasizes the importance of the Elixir community's commitment to education, documentation, and tools like liveBook, fostering an environment where people with varying skill levels can learn and contribute. The discussion highlights LiveView's capabilities and the role it plays in the future of Elixir, encouraging members to share knowledge and excitement for these tools through various channels.

Sophie invites listeners to attend and submit their talks for the upcoming Empex conference, which aims to showcase the best in Elixir and LiveView technologies. Additionally, the group shares light-hearted moments, reminding everyone to contribute to all types of documentation and promoting an inclusive atmosphere.

Key topics discussed in this episode:

• Updates on the latest release of the Programming Phoenix LiveView book
• The importance of community connection in Elixir conferences
• The future of documentation in the Elixir ecosystem
• The Elixir community's commitment to education and documentation
• LiveBook as a valuable tool for learning and experimenting
• Encouraging contributions across experience levels and skill sets
• Importance of sharing knowledge through liveBooks, blog posts, and conference talks
• Core Components in Phoenix LiveView, and modal implementation
• Creating a custom component library for internal use
• Reflecting on a Phoenix LiveView Project Experience
• Ease of using Tailwind CSS and its benefits in web development
• Advantages of LiveView in reducing complexity and speeding up project development
• LiveView's potential to handle large datasets using Streams
• The role of Elixir developers in the rapidly evolving AI landscape

Links in this episode:

Sophie DeBenedetto – https://www.linkedin.com/in/sophiedebenedetto
Programming Phoenix LiveView Book – https://pragprog.com/titles/liveview/programming-phoenix-liveview
Empex NYC - https://www.empex.co/new-york
SmartLogic - https://smartlogic.io/jobs
Phoenix LiveView documentation: https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
Live sessions and hooks: https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.Router.html#live_session/1
LiveView: https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
Tailwind CSS: https://tailwindcss.com/
Reuse Markup With Function Components and Slots
LiveView Card Components With Bootstrap
Building a Chat App With LiveView Streams

Special Guest: Sophie DeBenedetto.

Michael Lubas on the Future of Elixir Security

podcast@smartlogic.io (SmartLogic LLC) — Thu, 06 Apr 2023 06:00:00 -0400

In today's episode of Elixir Wizards, Michael Lubas, founder of Paraxial.io, joins hosts Owen Bickford and Bilal Hankins to discuss security in the Elixir and Phoenix ecosystem. Lubas shares his insights on the most common security risks developers face, recent threats, and how Elixir developers can prepare for the future.

Common security risks, including SQL injection and cross-site scripting, and how to mitigate these threats
The importance of rate limiting and bot detection to prevent spam SMS messages
Continuous security testing to maintain a secure application and avoid breaches
Tools and resources available in the Elixir and Phoenix ecosystem to enhance security
The Guardian library for authentication and authorization
Take a drink every time someone says "bot"
The difference between "bots" and AI language models
The potential for evolving authentication, such as Passkeys over WebSocket
How Elixir compares to other languages due to its immutability and the ability to trace user input
Potion Shop, a vulnerable Phoenix application designed to test security
Talking Tom, Sneaker Bots, and teenage hackers!
The importance of security awareness and early planning in application development
The impact of open-source software on application security
How to address vulnerabilities in third-party libraries
Conducting security audits and implementing security measures

Links in this episode:

Michael Lubas
Email - michael@paraxial.io
LinkedIn - https://www.linkedin.com/in/michaellubas/

Paraxial.io - https://paraxial.io/
Blog/Mailing List - https://paraxial.io/blog/index
Potion Shop - https://paraxial.io/blog/potion-shop
Elixir/Phoenix Security Live Coding: Preventing SQL Injection in Ecto

Twitter - https://twitter.com/paraxialio
LinkedIn - https://www.linkedin.com/company/paraxial-io/
GenServer Social - https://genserver.social/paraxial
YouTube - https://www.youtube.com/@paraxial5874

Griffin Byatt on Sobelow: ElixirConf 2017 - Plugging the Security Holes in Your Phoenix Application
Erlang Ecosystem Foundation: Security Working Group - https://erlef.org/wg/security
Article by Bram - Client-Side Enforcement of LiveView Security

Special Guest: Michael Lubas.

Cory O'Daniel and the Future of DevOps in Elixir Programming

podcast@smartlogic.io (SmartLogic LLC) — Thu, 30 Mar 2023 06:00:00 -0400

In this episode of Elixir Wizards, Cory O'Daniel, CEO of Massdriver, talks with Sundi and Owen about the role of DevOps in the future of Elixir programming. They discuss the advantages of using Elixir for cloud infrastructure and the challenges of securing cloud systems. They elaborate on their hopes for the future, including processes and automation to streamline operations so programmers can spend more time doing what they love … writing software!

Major topics of discussion in the episode:

Cory’s ideal ratio of hot sauce to honey (recommended for chicken)
Why this episode was renamed “how Cory almost killed his dad."
The history of deployment with Elixir and Erlang
The benefits of using Kubernetes to deploy Elixir applications
The future of Elixir DevOps and Massdriver's role in solving related problems
Benefits of reducing the operational burden for developers
Whether Elixir is a good fit for Kubernetes
How DevOps has changed over the last 10 years.
The confusion about what DevOps actually means
The idea of "engineers doing everything" is not sustainable
A future where engineers don't need to know much about DevOps, and can focus on writing code
Minimizing the operational burden for developers
Monolithic application vs. microservices
Why Massdriver does not use Webhooks to update configurations
Security, access to source code, and potential source leaks
The idea of multi-cloud, site-wide outage, and cloud agnosticism
Hybrid cloud vs true multi-cloud
Standardizing methods of packaging and deploying applications in the future

Links mentioned in this episode:

SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic
Massdriver — https://www.massdriver.cloud/
State of Production Survey (with Sweet Raffle Prizes) — https://blog.massdriver.cloud/surveys/state-of-production-2023/
$5000 Massdriver Credit — https://www.massdriver.cloud/partners/elixir-wizards
Elephant in the Cloud Blog Post — https://startups.microsoft.com/blog/elephant-in-the-cloud/
RIAK — https://github.com/basho/riak
Otel — https://hexdocs.pm/
Terraform — https://hexdocs.pm/terraform/Terraform.html
DigitalOcean — https://www.digitalocean.com/
Heroku — https://www.heroku.com/
Linode — https://www.linode.com/
Docker — https://www.docker.com/
Kubernetes — https://kubernetes.io/
Webhooks — https://hexdocs.pm/elixir_plaid/webhooks.html
GitOps — https://hexdocs.pm/git_ops/readme.html
Helm — https://helm.sh/docs/

Special Guest: Cory O'Daniel.

Season 10 Kickoff: The Hosts Discuss The Future of Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 23 Mar 2023 06:00:00 -0400

It’s the season 10 premiere of the Elixir Wizards podcast! Sundi Myint, Owen Bickford, and Dan Ivovich kick off the season with a spirited conversation about what they hope to see in the future of the Elixir programming language, experiences that inform their predictions, and excitement for this season’s lineup of guests.

They touch on how Elixir has evolved in the previous ten years and how the range of use cases has expanded beyond web development.

The hosts introduce the season 10 theme: The Next Ten Years of Elixir
Dan explains his initial hesitation and how he was ultimately won over by the language
Owen talks about functional programming and why Elixir piqued his interest
Sundi compares Elixir to other languages she’s worked with and why she thinks it’s more intuitive and readable
Sundi talks about her recent experience using Flutter for mobile application development
The hosts express excitement about the various ways Elixir is currently being used and its potential for growth
The Wizards express interest in hearing from guests this season to gain more perspective
They discuss Phoenix, LiveView, documentation, Flutter, Dart, and resources available to the Elixir community, and the benefits of being fluent in different programming languages
Owen suggests that Elixir and Phoenix are optimal for projects with limited resources and leaner teams
They highlight the importance of building resource-efficient apps that work well on low-powered devices
Dan expresses his desire to embrace types more but acknowledges that a first-party typing system is unlikely
The speakers discuss how Elixir has made complex tasks more accessible through features like LiveView, Phoenix Presence, WebSockets, Pub/Sub, Nerves, and ML libraries
They express excitement about the possibilities for the future of Elixir

Links mentioned in this episode:

That's a Wrap: Season 9 Finale with Sundi, Bilal, Owen & Dan!

podcast@smartlogic.io (SmartLogic LLC) — Thu, 29 Dec 2022 06:00:00 -0500

Elixir Wizards Season 9 is coming to an end! In the season finale, hosts Sundi, Bilal, Owen, and Dan reflect on the guests and highlights that made this season unforgettable. We thank you for joining us as we parsed the particulars and can't wait to reconnect next season for more insightful conversations!

*Please remember to take our LISTENER SURVEY so we can come back bigger and better for Season 10 – Coming in early 2023!! *

SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Marcelo Dominguez on Command and Query Responsibility Segregation

podcast@smartlogic.io (SmartLogic LLC) — Thu, 22 Dec 2022 06:00:00 -0500

Today on Elixir Wizards, Marcelo Dominguez, co-founder at Mimiquate, joins us to parse the particulars of command query responsibility segregation (CQRS). Mimiquate is a specialized team of developers providing solutions for their clients with Elixir, Ruby on Rails, and Ember. Tune in to learn the benefits and potential applications of CQRS.

*Please remember to take our LISTENER SURVEY so we can come back bigger and better for Season 10 – Coming in early 2023!! *

The Wizards catch up with Marcelo and hear about ElixirConf Uruguay and Advent of Code 2022
Marcelo and the hosts run through their experience with CQRS and event sourcing
The definition of CQRS
What is the elevator pitch for CQRS
Marcelo distinguishes between database writes and reads
What are some limitations of the CRUD pattern
How to know whether your application will benefit from the CQRS pattern
What tools are in the Elixir ecosystem for implementing CQRS
How to quickly recover from outages within a mature CQRS application
How multi-node distribution impact CQRS architecture

Links Mentioned in Today’s Episode:
Eventsourcing and CQRS in Elixir
CQRS Pattern (Microsoft)
Commanded (Hex Docs)
Advent of Code
Marcelo’s Advent of Code Gist for Day 1

Marcelo Dominguez on LinkedIn — https://uy.linkedin.com/in/marpo60
Marcelo Dominguez on Twitter — https://twitter.com/marpo60
Marcelo Dominguez on GitHub – https://github.com/marpo60
Mimiquate – https://www.mimiquate.com/
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Chris Miller on Crafting a Programming Language

podcast@smartlogic.io (SmartLogic LLC) — Thu, 15 Dec 2022 06:00:00 -0500

Today on Elixir Wizards, Chris Miller, software engineer at Corvus Insurance, joins us again for an in-depth discussion on the different approaches to programming. We dive into the conception and origin of new languages and how they evolve to solve new problems over time.

*Please remember to take our LISTENER SURVEY so we can come back bigger and better for Season 10 – Coming in early 2023!! *

Key Points From This Episode:

The hosts catch up with Chris and learn a bit about Corvus Insurance
What excites Chris about programming language and new ways of thinking
Chris' fascination with all different types of languages from Chinese to Greek to C++
We get a refresher on the concept of Domain Specific Language
What DSL is being used for certains problems in the domain at Corvus Insurance
Why a coder should care about the crafting of a programming language
We discuss why all coders don't only write assembly code
Chris breaks down how he has attempted to write his own programming language
We learn some inside tips on how stay within the abstract boundary when building a domain
How Chris' experience with multiple coding languages has influenced his work in Elixir
What the advantage of knowing multiple languages is

Links Mentioned in Today’s Episode:

Corvus Insurance on Twitter — https://twitter.com/CorvusInsurance
Corvus Insurance -- https://www.corvusinsurance.com/
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Frank Hunleth and Joe Martin on the Particulars of Nerves

podcast@smartlogic.io (SmartLogic LLC) — Thu, 08 Dec 2022 06:00:00 -0500

Today on Elixir Wizards, we speak with two great minds in the Elixir community: Frank Hunleth from SmartRent and Joe Martin from Company Six. Join us to parse the particulars of Nerves, from production and terminology, to stacks, customization, and how they function.

*Please remember to take our LISTENER SURVEY so we can come back bigger and better for Season 10 – Coming in early 2023!! *

Key Points From This Episode:

How both Frank & Joe became interested in Elixir
We learn what nerves is currently being used for in production
How Nerves is being utilized within farming and energy companies
What the elevator pitch for nerves would be
How well nerves play with pre-existing embedded projects in other languages, especially when having to coexist within a system
How much can a user customize nerves
What is Buildroot and the functions that it serves
Frank explains how there are two worlds: elixir world & nerves systems
Joe and Frank let us know what they are most excited about in the near future of nerves and Elixir

Links Mentioned in Today’s Episode:

LISTENER SURVEY – https://smr.tl/survey2022
Nerves Livebook – https://github.com/livebook-dev/nerves_livebook
Frank Hunleth on LinkedIn — https://www.linkedin.com/in/fhunleth/
Frank Hunleth on Twitter — https://twitter.com/fhunleth
Frank Hunleth on GitHub -- https://github.com/fhunleth
Joe Martin on LinkedIn — https://www.linkedin.com/in/joseph-martin-265861b2/
Joe Martin on GitHub – http://github.com/josephmartin09
SmartRent -- https://smartrent.com/
Company Six – https://www.co6.com/
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Jenny Bramble on Testing and Collaboration at Papa

podcast@smartlogic.io (SmartLogic LLC) — Thu, 01 Dec 2022 06:00:00 -0500

Today on Elixir Wizards, we chat with Jenny Bramble. Jenny is the Director of Quality Engineering at Papa, a platform that connects older adults and low-income families with companionship and a helping hand with daily tasks. Tune in to learn more about Jenny's experience with testing and team collaboration at Papa.

Key Points From This Episode:

Jenny tells us about her journey to learning Elixir (for 8 years now!)
We learn about the 24 talks that Jenny has done as a keynote speaker
The breakdown of her talk this year at Elixir Conf on upgrades
How Jenny got in to writing tests after going to college for computer science
What goes into developer handoff and how that varies depending on the company and team
The connection and importance between customer service and empathy
What it's like to work in Quality Engineering and Testing at Papa
What is testing?
She provides helpful tips of things that tend to be caught up by QA during code reviews
Jenny has a course on management for Test Automation coming out in 2023!

Links Mentioned in Today’s Episode:

Jenny Bramble on LinkedIn — https://www.linkedin.com/in/jennybramble/
Jenny Bramble on Twitter — https://twitter.com/jennydoesthings
Jenny Bramble on GitHub -- https://github.com/jennydoesthings
Papa -- https://www.papa.com/
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Harper Atlas on Tailwind From the Perspective of a Designer

podcast@smartlogic.io (SmartLogic LLC) — Thu, 17 Nov 2022 06:00:00 -0500

We are excited to have SmartLogic's own Harper Atlas as our guest on Elixir Wizards today! Harper, a product designer at SmartLogic (and cat lady at home), joins us on this episode to parse the particulars of the Tailwind framework from a designer's perspective. Join us to gain insights from our first non-engineer guest in this spirited conversation with Harper!

Key Points From This Episode:

We learn about Harper’s journey into the UX field
Harper breaks down her day-to-day life as a product designer at SmartLogic
What the difference between FigMa and FigJam is
The good & bad sides of Tailwind
What goes into developer handoff and how that varies depending on the company and team
The importance of finding common language and bridging the gap between developer island and design island within a developer handoff
The features that Harper doesn’t like about Tailwind
How Tailwind has started to feel like the Baader-Meinhof Phenomenon
Harper gives developers some advice on how to be more helpful to designers while working in a Tailwind space

Links Mentioned in Today’s Episode:

Harper Atlas on LinkedIn — https://www.linkedin.com/in/harper-atlas
Harper Atlas on Twitter — https://twitter.com/harperatlas
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Theo Harris on Onboarding into Elixir at Alembic

podcast@smartlogic.io (SmartLogic LLC) — Thu, 10 Nov 2022 06:00:00 -0500

Today on the show we’re excited to have Theo Harris here to discuss Onboarding Into Elixir. Theo is a technical consultant working for Alembic in Sydney, Australia. He is currently working on a project utilizing Elixir and Phoenix LiveView. Tune in today to learn more about Onboarding Into Elixir, from our guest Theo Harris!

Key Points From This Episode:

A brief breakdown of today’s topic and introduction to our special guest, Theo Harris
Theo lets us in on his current hot tech take
We discuss accessibility tips and tricks
Theo gives us the run down on Alembic and what they do at their company
We find out whether or not Theo has a pet dinosaur
We learn of the technical challenges that Theo has faced as an Elixir Engineer
The breakdown of the onboarding process at Alembic
Theo gives advice to beginners on how to learn Elixir/Phoenix

Links Mentioned in Today’s Episode:

Theo Harris on Twitter — https://twitter.com/dino_coder
Theo Harris on GitHub — https://github.com/Theosaurus-Rexv
Theo Harris on LinkedIn — https://www.linkedin.com/in/theo-harris-coder/
Alembic — https://alembic.com.au/
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Ashley Smith & Kenneth Moy from Bowery Farming on Oban

podcast@smartlogic.io (SmartLogic LLC) — Thu, 03 Nov 2022 06:00:00 -0400

On today’s episode of Elixir Wizards, Ashley Smith and Kenneth Moy from Bowery Farming join us to dive into the particulars of Oban. Ashley has been working as a software engineer for 3 years with full-stack experience working mainly on web applications and now works in elixir at Bowery Farming. Kenneth is a software engineer at Bowery Farming with 3 years of elixir experience. Tune in today to learn more about Oban from today’s special guests, Ashley & Kenneth!

Key Points From This Episode:

A brief breakdown of today’s topic and introduction to our special guests, Ashley & Kenneth
We get the inside scoop of what happens behind the scenes at Bowery Farms and how they use elixir
What is Oban and how does it compare to other languages
Why one would use Oban rather than something like Broadway
How Oban is useful at Bowery Farms
Ashley & Kenneth explain why they are not “over” Ecto.Multi just yet
We hear about their working experience at Bowery, some days are remote, some days are at the office, and some days are at the farm where they get to see their work come to life

Links Mentioned in Today’s Episode:

Ashley Smith on GitHub — https://github.com/asmith1
Ashley Smith on LinkedIn — https://www.linkedin.com/in/ashley-smith-951802126/
Kenneth Moy on Twitter — https://mobile.twitter.com/chehitskenniexd
Kenneth Moy on GitHub — https://github.com/chehitskenniexd
Kenneth Moy on LinkedIn — https://www.linkedin.com/in/kenneth-moy/
Bowery Farms — https://boweryfarming.com
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Jason Stiebs on LiveView at RokkinCat

podcast@smartlogic.io (SmartLogic LLC) — Thu, 27 Oct 2022 06:00:00 -0400

Today we welcome Jason Stiebs to the podcast to talk about all things LiveView and how he was originally wrong about LiveView in the beginning. Jason is the founder at Rokkincat, and a core contributor to Phoenix. Jason loves finding solutions to complex problems and mentoring young engineers. Tune in today to learn more about LiveView from today’s special guest, Jason Stiebs!

Key Points From This Episode:

A brief breakdown of today’s topic and introduction to our special guest, Jason Stiebs
A summary of Jason’s talk at ElixirConf on why he initially was wrong about LiveView
How Jason became a Phoenix core team member
What is stopping LiveView from being 1.0
Is there something that would make LiveView ‘complete’
How to decide to use LiveView over an SPA framework
Do you know if there are any folks out there putting together tooling for LiveView? Thinking like Chrome devtools, performance monitoring, etc. What tools can we use to compare our LiveView performance to non LV performance?
What Jason's thoughts about a time traveling feature for LiveView like what React / Redux has
What some featuresare from other frameworks that Jason would like to see in LiveView one day
How often Jason sees mixed LV and non LV projects
We hear about what's next in terms of features for functional components

Links Mentioned in Today’s Episode:

Jason Stiebs on Twitter — https://twitter.com/peregrine
Jason Stiebs on GitHub — https://github.com/jeregrine
Jason Stiebs on LinkedIn — https://www.linkedin.com/in/jasonstiebs/
Jason Stiebs Email Address – jason@rokkincat.com
RokkinCat — https://rokkincat.com/
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Mark & David from Thinking Elixir on Ecto Queries

podcast@smartlogic.io (SmartLogic LLC) — Thu, 20 Oct 2022 06:00:00 -0400

This week the Thinking Elixir Podcast is taking over Elixir Wizards! Mark & David from Thinking Elixir are here today to parse the particulars of Ecto Queries! Mark Ericksen is an Elixir Specialist at Fly.io and host of Thinking Elixir. David Bernheisel is a Senior Software Engineer at Bitfo and host of Thinking Elixir. Tune in today to learn more about Ecto Queries from today’s special guests, Mark Ericksen and David Bernheisel!

Key Points From This Episode:

A brief breakdown of today’s topic and introduction to our special guests, Mark & David
The hosts catch up with Mark & David and learn about David’s new book Ecto In Production
Dave Lucia is mentioned once again, can we go one episode without talking about him?
Find out how long David & Mark have been working in databases
We get the breakdown of what an Ecto Query is
There is a discussion around schema migrations vs data migrations and how to avoid common pain points
Learn what resources are available for learning Ecto
We find out what the pin operator is and when it is used
What an extensive query is and how to optimize queries
We learn about fun edge cases that we’ve bumped into while working with Ecto
The ins and outs of Ecto dump and Ecto load

”Ecto is a whole wide world of information. You think you know a lot and then you realize you don't. Nope, I'm almost just as dumb as I was five years ago about SQL and Ecto. Nope, it evolves. It gets deep.” - Mark Ericksen

Links Mentioned in Today’s Episode:

Mark Ericksen on Twitter — https://twitter.com/brainlid
Mark Ericksen on LinkedIn — https://www.linkedin.com/in/mark-ericksen-66397417/
David Bernheisel on Twitter – https://twitter.com/bernheisel
David Bernheisel on GitHub – https://github.com/dbernheisel
David Bernheisel on LinkedIn – https://www.linkedin.com/in/bernheisel/
Thinking Elixir Podcast https://podcast.thinkingelixir.com/
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic
Use The Index, Luke! https://use-the-index-luke.com/
Postgresql Tutorial https://www.postgresqltutorial.com/
Postgresql subqueries
https://stackoverflow.com/questions/3004887/how-to-do-a-postgresql-subquery-in-select-clause-with-join-in-from-clause-like-s
https://www.w3resource.com/sql/subqueries/understanding-sql-subqueries.php
Fly Blog: Safe Ecto Migrations https://fly.io/phoenix-files/safe-ecto-migrations/
Crunchy Data Developer Tutorials https://www.crunchydata.com/developers/tutorials
Crunchy Data Postgres Tips https://www.crunchydata.com/postgres-tips
Ecto in Production https://www.ectoinproduction.com/
SQL Join Illustration https://commons.wikimedia.org/wiki/File:SQLJoins.svg
SQL Join Illustration https://i.stack.imgur.com/UI25E.jpg

Tyler Young on Geo Mapping at Felt

podcast@smartlogic.io (SmartLogic LLC) — Thu, 13 Oct 2022 06:00:00 -0400

Today on Elixir Wizards we are joined by Tyler Young to explore the particulars of Geo Mapping, the process of turning data into maps. Tyler is a Senior Software Developer at Felt, the world’s first collaborative mapping tool built for anyone to make a beautiful map in minutes. Tune in today to learn more about Geo Mapping from today’s special guest, Tyler Young!

Key Points From This Episode:

A brief breakdown of today’s topic and introduction to our special guest, Tyler Young
We discover Tyler’s background and how he started working in Elixir, as well as how he got into the map business because of his love for Elixir
We learn about GIS and its history as a system/standard/protocol, and how someone can study GIS
Find out how mapping is helpful in more ways than just for directions, including climate changes, vacation planning, and more
Tyler breaks down the common technologies and toolkits for programming with maps
The specific tools that Felt is using to ingest map data and build the interactive maps
What common problems arise when developing with maps
Tyler teaches the Elixir Wizards about his tried and true way of decision making with “The McDonald’s option”
_
**Links Mentioned in Today’s Episode:
Tyler Young on Twitter — https://twitter.com/TylerAYoung
Tyler Young on GitHub — https://github.com/s3cur3
Tyler Young on LinkedIn — https://www.linkedin.com/in/tyler-young-dev/
Felt — https://felt.com/about
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Kate Rezentes on GenServers at Simplebet

podcast@smartlogic.io (SmartLogic LLC) — Thu, 06 Oct 2022 06:00:00 -0400

Season 9 is in full swing and we are so excited to welcome Kate Rezentes today to dive into the particulars of GenServers. Kate is a Junior Software Developer at Simplebet, a B2B product development company using machine learning and real-time technology to make every moment of every sporting event a betting opportunity. Tune in today to learn more from today’s special guest, Kate Rezentes!

Key Points From This Episode:

A brief breakdown of today’s topic and introduction to our special guest, Kate Rezentes
We learn about Kate’s background and her long history with programming
We discuss how many conferences she’s attended and why ElixirConf has been her favorite (thus far)
Find out how Kate landed a job while attending ElixirConf
How GenServers as a subject came to be
We get an inside look at Kate’s working experience at Simplebet and her experience as a Junior Engineer in the industry so far
What cases in particular cause the need for a GenServer
We discuss where GenServers would be appropriate to use and why
The ins and outs of ‘handle calls’ and ‘callbacks’
The process of testing a GenServer and data storage_

**Links Mentioned in Today’s Episode:*

Kate Rezentes on Twitter — https://twitter.com/rezkate
Kate Rezentes on GitHub — https://github.com/KateRezentes
Kate Rezentes on LinkedIn — https://www.linkedin.com/in/kfrezent/
Simplebet — https://simplebet.io/
SmartLogic — https://smartlogic.io/
SmartLogic Twitter — https://twitter.com/smartlogic

Dave Lucia on Observability at Bitfo

podcast@smartlogic.io (SmartLogic LLC) — Thu, 29 Sep 2022 03:00:00 -0400

Welcome to our first episode of Season 9 Elixir Wizards, Parsing the Particulars. A show focused on conversations with software developers from around the world on the Elixir language and other modern web technologies. Today, we are joined by Dave Lucia, Chief Technology Officer at Bitfo, a cryptocurrency media company building educational content for people who are interested in cryptocurrency. Dave is active in the Elixir community and in the past has spoken at Code BEAM SF, ElixirConf, RabbitMQ Summit, and has written several blog posts which can be found at davelucia.com. In today’s episode we find out more about Dave’s professional background and dive into the particulars of observability. Tune in today to learn more from today’s special guest, Dave Lucia!

Key Points From This Episode:

A brief breakdown of today’s topic and introduction to our special guest, Dave Lucia
We find out about Bitfo and what services they offer
We discuss Dave’s blog post on observability
Find out how Dave wrote the blog post because he saw a gap at his company
How Sundi proofread Dave’s blog post and realized her lack of knowledge on observability
The most common mistake teams or engineers make when it comes to observability
We peel back the layers on what telemetry is
What the difference between telemetry and OpenTelemetry is
How to choose which tool is right when it comes to better observability *The breakdown of the uses for observability telemetry *When and why would we use OpenTelemtry vs basic observability *What languages Dave started in before he was working in Elixir *How Elixir lends better for observability *Where to start if you want to implement basic observability for someone who has no experience with it *Dave answers the question, “can you go too far with observability?” *We discuss Livebook and what exciting things it will bring for the future *Most importantly, Dave explains why pineapples are important to him

**Links Mentioned in Today’s Episode:

Dave’s blog post on Observability: https://davelucia.com/blog/observing-elixir-with-lightstep
Dave Lucia on Twitter — https://twitter.com/davydog187
Dave Lucia on GitHub — https://github.com/davydog187
Dave Lucia on LinkedIn — https://www.linkedin.com/in/david-lucia-a395441b/
Bitfo — https://www.bitfo.com/
SmartLogic — https://smartlogic.io/

Links:

Spotify

We're baaaack! Season 9 Teaser

podcast@smartlogic.io (SmartLogic LLC) — Thu, 22 Sep 2022 00:00:00 -0400

Hey everyone, Season 9 of Elixir Wizards is back! This season's theme is Parsing the Particulars, where we dive into particular subjects with our guests. Your returning hosts this season are Sundi, Owen and Dan! And we are excited to announce that we have a new host joining the show - Bilal Hankins! Bilal is a Software Developer at SmartLogic and is super excited to join us this season.

Some of this season's guests include Dave Lucia, CTO at Bitfo, Tyler Young, Senior Software Developer at Felt, and Kate Rezentes, Junior Developer at SimpleBet. Can't wait to see you there!

SmartLogic — https://smartlogic.io/
SmartLogic on Twitter — https://twitter.com/smartlogic
SmartLogic on LinkedIn — https://www.linkedin.com/company/smartlogic-io/
SmartLogic on Facebook — https://www.facebook.com/smartlogic/
Bilal Hankins on LinkedIn — https://www.linkedin.com/in/hankins-bilal/
Sundi Myint on LinkedIn — https://www.linkedin.com/in/sundimyint/
Owen Bickford on LinkedIn — https://www.linkedin.com/in/owen-bickford-8b6b1523a/

Looking back on Season 8 with Sundi, Owen & Dan

podcast@smartlogic.io (SmartLogic LLC) — Wed, 29 Jun 2022 06:00:00 -0400

It’s the season finale show! Can you believe it? Join us this week as Sundi, Owen, and Dan take a look back at this season of Elixir Wizards! You’ll hear their discussion about favorite moments over the season and learn about this season’s theme and its origin, and what they learned throughout the season. Enjoy and we hope to see you back for Season 9!

Key Points From This Episode:

Reflection on the guests experiences with all different types of language
How the team landed on the theme of Elixir in a Polyglot Environment
Having expectation of guests vs how the conversation turned out
The discovery that environment influences the strength of the code that is being written
We dig deeper into the flexibility of all of these companies
How the hosts enjoyed the dream language combination answers from guests
We hear about the teams experience with their first in-person recording
Hearing about guests personal experiences and projects vs just their at-work experience
We find out what birds do when they’re excited in a tree
Flutter as a solution for building mobile applications
The hosts likes, dislikes, experience with Flutter and the difference it brings to the table
We reflect on a guest applying gamification
The hosts discuss the guests range of experience, from a year to decades in the field, and how many different perspectives were shown with different backgrounds
A recurring theme of the guests: structuring teams to fit the needs of the company - recurring theme
Hearing about products and projects guests are working on

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
SmartLogic on Twitter — https://twitter.com/smartlogic
SmartLogic on LinkedIn — https://www.linkedin.com/company/smartlogic-io/
SmartLogic on Facebook — https://www.facebook.com/smartlogic/
Dan Ivovich on LinkedIn — https://www.linkedin.com/in/divovich/
Sundi Myint on LinkedIn — https://www.linkedin.com/in/sundimyint/

Nathan Retta on Engineering in Android at DoorDash

podcast@smartlogic.io (SmartLogic LLC) — Thu, 23 Jun 2022 06:00:00 -0400

This week on Elixir Wizards we’re joined by Nathan Retta, Senior Software Engineer from Android at DoorDash. We learn about Nathan’s background; his experience having a degree in Chemical Engineering and working in Oil and Gas for 6 years. Nathan then wrote an Android app in 2016 and soon after became a mobile developer -- the rest is history. He is currently based in Denver, Colorado, and our host Owen has met him prior through the Denver Elixir virtual meet up.

Join us today for this conversation between Owen, Dan and Nathan as we learn about Nathan’s experience leading up to his current position at Android for DoorDash and how he is using Elixir in his side projects.

Cara Mitchell on Internal In-house eCommerce

podcast@smartlogic.io (SmartLogic LLC) — Thu, 16 Jun 2022 06:00:00 -0400

Welcome to this week’s episode of Elixir Wizards, with our special guest, Cara Mitchell of Pepsi Co. Today we speak with Cara about her career journey that led to her living in the lower East Side of New York City. Cara has been working in the software engineering field for over 20 years and currently works at PepsiCo on their in-house eCommerce platform built with Elixir. Over the years, she's worked on systems that range from embedded firmware to large distributed systems running on thousands of machines. She enjoys working in a number of programming languages and refuses to pick a favorite. Today we learn about Cara’s unique experience as a college dropout turned self-made software engineer and how PepsiCo is working in Elixir on a global scale with an inside look at the goings on at PepsiCo. Tune in today to learn more from today’s special guest, Cara Mitchell!

Catalina Astengo on The Many Languages of Nav

podcast@smartlogic.io (SmartLogic LLC) — Thu, 09 Jun 2022 07:30:00 -0400

Joining us today on Elixir Wizards is Catalina Astengo, Staff Software Engineer at Nav Inc. We chat with Catalina about how she went from working as a process engineer in a mine to a software engineer in beautiful Salt Lake City.

In today’s show we find out more about Catalina’s professional background, how and why she started taking Ruby courses while working at a mine in southern Utah, how she fell in love with Salt Lake City and what it looked like transitioning to a new profession. We learn about the ins & outs of Nav and their team roles, as well as how they keep up with all of the languages that they are using including Elixir, Ruby, Go and JS. Tune in today to learn more from today’s special guest, Catalina Astengo!

Key Points From This Episode:

A brief breakdown of today’s topic and introduction to our special guest, Catalina Astengo.
What it was like working in a small town in a mine in southern Utah
What a process engineer is and what the job title entails
What prompted the switch from process engineering to software engineering
What Nav does as a company
Catalina gives us a rundown of her professional career.
Is this the most Polyglot stack we have encountered this season!?
The ins & outs at Nav and their teams roles
How Nav uses Elixir on a daily basis
How Nav keeps up to date on all of the languages they are using
Concerns about using multiple languages on the backend
Context switching between languages
How Nav decided to use Golang and why she prefers Elixir
Where Nav is based and where they are hiring
How Catalina and her team made a home movie production of Beetlejuice
We review Elixir Conf 2020 and takeaways that Catalina had from the conference
How Nav uses GRPC
RP vs GRPC - what’s the difference?
Protobuf for validation schemes across GPS
Ways to validate event payloads by using the Graph QL
We discuss our experience with management vs. coding
Owens penguin discovery about Catalina on the Nav website

Links Mentioned in Today’s Episode:

Catalina Astengo on Twitter — https://twitter.com/catalinaastengo
Catalina Astengo on GitHub — https://github.com/castengo
Catalina Astengo on LinkedIn — https://www.linkedin.com/in/catalinaastengo/
Blog Post on Graph QL Schema Validation – https://www.infoq.com/news/2022/05/graphql-schema-validation/
Nav Careers — https://www.nav.com/
SmartLogic — https://smartlogic.io/
SmartLogic on Twitter — https://twitter.com/smartlogic
SmartLogic on LinkedIn — https://www.linkedin.com/company/smartlogic-io/
SmartLogic on Facebook — https://www.facebook.com/smartlogic/
Sundi Myint on LinkedIn — https://www.linkedin.com/in/sundimyint/

Meks McClure on Communication, Diversity, and Ergonomics

podcast@smartlogic.io (SmartLogic LLC) — Thu, 02 Jun 2022 06:00:00 -0400

Welcome to another episode of Elixir Wizards, a show focused on conversations with software developers from around the world on the Elixir language and other modern web technologies. In today’s episode, we speak with Meks McClure, a Full Stack Software Engineer with an unconventional background in Biology and Philosophy. Meks found their passion for programming after building a website for a Mexican non-profit, Permanencia Voluntaria, using wix.com. Seeing people use the website and how it helped the community inspired Meks to pursue a career in programming. They are currently based at NewAperio, a software development company, as a Junior Developer. In today’s show we find out more about Meks’s professional background, NewAperio and the services they offer, more about their unconventional training background, challenges transitioning to a new career path, the importance of effective communication in the workplace, the significance of Pride Month, Meks’s very cool desk setup, and much more! Tune in today to learn more from today’s special guest, Meks McClure!

Key Points From This Episode:

A brief breakdown of today’s topic and introduction to our special guest, Meks McClure.
We find out about NewAperio and what services they offer.
How long Meks has been based at NewAperio.
Find out what the NewAperio tradition is for people celebrating their work anniversary.
A light-hearted discussion about singing Happy Birthday to colleagues.
Meks gives us a rundown of their professional career.
We find out more about Meks’s non-traditional programming background.
How long they have been using Elixir for and how they initially got started in it.
The lessons they learned from their Flatiron and Elixir development experience.
What was most difficult transitioning from working Ruby to Elixir.
Keeping a balance between learning and meeting productivity targets.
The moment when Meks felt like they were making good progress transitioning.
Some advice they have for people learning Elixir.
Other projects that Meks is currently working on and programming languages used.
How boot camp is different from real-world situations, in terms of programming.
We find out about Meks’s current Star Wars obsession.
The importance of finding enjoyment outside of work.
Meks shares their personal journey to becoming the person they are today.
A conversation about the importance of Pride Month and keeping an open mind.
A highlight of some communication challenges that come with remote working.
Why empathetic and effective communication is essential in the workplace.
We reflect on some recent networking opportunities and conferences.
The approach at NewAperio to networking and conferences.
Details about Meks’ desk setup and why it is called the ‘Moon Lander’.
More about their desk setup: keycap preferences.
How learning Elixir changed the way Meks thinks about programming in general.
Meks explains their approach to writing code.
What their ultimate combination of programming languages are.
What opportunities or weaknesses that a polyglot environment can introduce.

*Links Mentioned in Today’s Episode:
*

Meks McClure on Twitter — https://twitter.com/mmcclure0100
Meks McClure on GitHub — https://github.com/MMcClure11
Meks McClure on LinkedIn — https://www.linkedin.com/in/meksmcclure/
NewAperio — https://newaperio.com/
SmartLogic — https://smartlogic.io/
Sundi Myint on Twitter — https://twitter.com/sundikhin
Owen Bickford on Twitter — https://twitter.com/owenbickford/
SmartLogic — https://smartlogic.io
Moon Lander — https://www.zsa.io/moonlander/
Difficult Conversations — https://www.penguinrandomhouse.com/books/331191/difficult-conversations-by-douglas-stone-bruce-patton-and-sheila-heen-foreword-by-roger-fisher/
Kailh Speed Silver (Linear) Mechanical Switch Kit — https://www.amazon.com/Silver-Linear-Mechanical-EVGA-Keyboard/dp/B09N9BXW7Z

Special Guest: Meks McClure.

Jessica Kerr on Systems Thinking for Developers

podcast@smartlogic.io (SmartLogic LLC) — Thu, 26 May 2022 06:00:00 -0400

A superpower of software development is teaching our code to teach us what’s happening. This is observability, and it’s why Jessica Kerr works at Honeycomb, where she is a Developer Advocate. After twenty years as a developer, Jess sees software as a significant force in the world. As a symmathecist in the medium of code, she views development teams as learning systems made of both people and software. She believes that, if we allow the software to teach us, it becomes a better teammate and, if this process makes us into systems thinkers, we can be better people in the world! Today, Jess compares the way we work in teams to game design and we find out what she means by observability and how it can serve everybody on a team. She elaborates on the remarkable agency that software developers have and how the languages they use can empower them, especially when they aren’t having specific architecture imposed on them! We also touch on what being a polyglot means to Jess, the value of working with rather then against complexity, and what Jess means when she says a software team is the perfect example of a symmathesy, plus so much more, so make sure to tune in today for this fascinating conversation with Jessica Kerr!

*Key Points From This Episode:
*

Jess starts by drawing an interesting comparison between teamwork and game design.
Insight into her journey as a developer and how she was introduced to Elixir.
Discover Jess’ connection to Elixir iteratees via Jose Valim!
Her role at Honeycomb, the languages she uses, and what she means by observability.
Why Jess believes that developers have agency and enormous power.
Why the best language to use is the one that you and your team know best.
The value of standardizing the platform rather than trying to dictate the language.
How observability reveals connections and acts as one tool that serves everybody.
Congressive versus ingressive behavior as per Dr. Eugenia Cheng.
What being a polyglot means to Jess: accepting that others don’t think just like you do and actively learning from them.
Working skillfully within complexity rather than trying to eliminate it.
How people gain exposure to different languages at Honeycomb.
The importance of understanding what architecture is being imposed on you.
Jess’ favorite talk on symmathesy and why a software team in particular is a symmathesy.
Opportunities and/or weaknesses that being in a polyglot environment can introduce.
Ways you can connect with Jess and even sign up for a 30-minute chat with her!

*Links Mentioned in Today’s Episode:
*
Jessica Kerr — https://jessitron.com/
Jessica Kerr on LinkedIn — https://www.linkedin.com/in/jessicakerr/
Jessica Kerr on Twitter — https://twitter.com/jessitron
Honeycomb — https://www.honeycomb.io/
Schedule a Call with Jess — honeycomb.io/office-hours
Games: Agency As Art — https://objectionable.net/games-agency-as-art/
OpenTelemetry — https://opentelemetry.io/
Matthew Skelton — https://blog.matthewskelton.net/
Team Topologies — https://teamtopologies.com/
QCon — https://plus.qconferences.com/
Keynote: ’The Language is the Least of It’ — https://youtu.be/nvV-4040xXI
Dr Eugenia Cheng — http://eugeniacheng.com/
x + y — https://www.basicbooks.com/titles/eugenia-cheng/x-y/9781541646513/
'Backend for frontend (BFF) pattern’ — https://medium.com/mobilepeople/backend-for-frontend-pattern-why-you-need-to-know-it-46f94ce420b0
Abstract syntax tree — https://en.wikipedia.org/wiki/Abstract_syntax_tree
Keynote: ‘Collective Problem Solving in Music, Science, Art, and Software’ — https://jessitron.com/2019/11/05/keynote-collective-problem-solving-in-music-science-art-and-software/
SmartLogic — https://smartlogic.io/

Special Guest: Jessica Kerr.

Digit on Smart Homes, EMPEX, and Cross-platform Development

podcast@smartlogic.io (SmartLogic LLC) — Thu, 19 May 2022 06:00:00 -0400

Welcome back to another episode of Elixir Wizards. Today, we chat with Digit, a talented software engineer currently based at SmartRent. He became aware of the company when he started trying to modify his smart home and realized what was behind the software. Digit works on building applications within the SmartRent suite of tools using the Nerves ecosystem. Although fairly new at SmartRent, Digit loves the powerful applications of the software they are developing. In today’s show we find out more about the work Digit is currently involved with at SmartRent and what they have in store for the future. We also discuss the pros and cons of living in a smart home, the different languages that Digit uses, what makes developing a game so challenging, Using Elixir for building DSLs to generate content for Unity, what Digit’s opinion is of Burrito, and much more! For all this and more, be sure to tune in today!

Key Points From This Episode:

Introduction to today’s show and brief catch-up of what everyone has been up to.
We find out what talks at the conference Digit is most looking forward to.
What OTP stands for: hint, it is not ‘Open Telephony Platform.’
A brief discussion about the advantages of a one-day conference.
We find out who all the people are that are going to give talks at EMPEX.
Digit shares what it has been like working at SmartRent.
We find out how Digit landed the job at SmartRent.
Breakdown of what SmartRent is in terms of the high level.
We get some insider knowledge of the next-generation technology at SmartRent.
Rundown of what Flutter is and the advantages of using it.
Discussion about the pros and cons of living in a smart home.
Find out what the best smart thermostat is, according to Digit.
The different programming languages that Digit is currently working in.
Digit explains the type of WebSocket support available in Flutter.
Background about Digit’s experience in game development.
What makes finishing developing a game so difficult.
The language stack used to develop games.
Using Elixir for building DSLs to generate content for Unity.
Digit gives listeners an overview of Burrito.
The advantages of using Burrito for cross-platform with no internet connection.
Examples of real-world applications using Burrito.
Other applications for Elixir outside of web application development.
We get some insider information about a new Elixir-based project in the works.
A rundown of the security applications using Macaroons.
The power that passwordless authentication has to offer.
We end the show with some takeaways from Digit for listeners.

Links Mentioned in Today’s Episode:

Digit — https://puppy.surf
Digit on GitHub — https://github.com/doawoo
Digit on Twitter — https://twitter.com/doawoo
SmartRent — https://smartrent.com
SmartLogic — https://smartlogic.io/
Sundi Myint on Twitter — https://twitter.com/sundikhin/
Owen Bickford on Twitter — https://twitter.com/owenbickford/
EMPEX — https://www.empex.co
Flutter — https://flutter.dev/

Special Guest: Digit.

Nathan Willson on the Polyglot Landscape in Japan

podcast@smartlogic.io (SmartLogic LLC) — Thu, 12 May 2022 06:00:00 -0400

Joining us in conversation today is Nathan Willson all the way from Tokyo, Japan. Listeners will learn about the polyglot landscape he works in from Japan, why he believes knowing a language, and mastering it, are two different things, and what his first foray into coding looked like. We touch on the necessary evil of MIDI plugins, and Nathan introduces listeners to GEMS, how you can use it, and what he has done to make it accessible across the globe. We talk latency issues, curbing the potential for abuse, and choosing to make an app open source, before delving into Nathan’s other projects outside of GEMS, including the Elixir app, Biddy, that he built with five friends, When to Chat, and much more. Thanks for tuning in to hear from today’s inspiring guest.

Key Points From This Episode:

An introduction to today’s guest, Nathan Willson, his Canadian-Japanese history, his obsession with Elixir, and his musical experimental app, GEMS.
The polyglot environment in which he works which is Japanese and English.
Why knowing a language and mastering a language are such different things.
His first foray into coding via Reaper’s plugins.
Why he considers MIDI to be a necessary evil.
What GEMS, or Globally Editable Matrix Sequencer, is, and how it works.
How Phoenix or Elixir can facilitate the use of GEMS anywhere in the world, at the same time.
How he has approached the problem of the potential for abuse.
Relative and absolute latency and how that impacts user experience between countries.
Nathan’s other projects outside of GEMS, including the Elixir app, Biddy, and TreeLib.
The app, When to Chat, that Nathan has built.
Where he picked up his design skills with a background in back-end engineering.
Why he prefers BandCamp to Spotify as a music listener.
How his knowledge of Elixir has helped him to code Ruby better.
An invitation from Nathan to reach out with what you are working on.

Links Mentioned in Today’s Episode:

Tone.js — https://tonejs.github.io/
BandCamp — https://bandcamp.com/
Nathan Wilson — https://nathanwillson.com/
Nathan Willson on Twitter — https://twitter.com/nathanwillson
Nathan Willson on Instagram — https://www.instagram.com/nahtanw/
GEMS — https://gems.nathanwillson.com/
What is Max? | Cycling ‘74 — https://cycling74.com/products/max
When to Chat —https://whentochat.co/
SmartLogic — https://smartlogic.io/

Special Guest: Nathan Willson.

Sanne Kalkman on Coding, Crafting, and Collaboration

podcast@smartlogic.io (SmartLogic LLC) — Thu, 05 May 2022 08:00:00 -0400

This week we are joined by Sanne Kalkman, former teacher turned software engineer. Currently, Sanne works at CodeSandbox, where she's one of two Elixir developers responsible for the backend. When she's not coding, you'll probably find her either 25 browser tabs deep into a new CS topic, learning yet another new hobby, or behind her sewing machine, all of which we dive into in today’s episode! Tuning in, you’ll discover which languages Sanne is proficient in and why she doesn’t consider herself a polyglot; gain some insight into CodeSandbox Projects, a more collaborative rewrite of CodeSandbox from the ground up; and get a sneak peek into Sanne’s upcoming keynote address at Code BEAM Europe in May 2022, which tackles how to help juniors succeed in your organization. We also touch on garbage collection in Elixir, cute avatars, the intersection of code and sewing, and much, much more, so make sure not to miss this fun and insightful conversation with coder and crafter, Sanne Kalkman!

Key Points From This Episode:

What it’s like living in the Netherlands, Sanne’s favorite TV show, and more.
An introduction to Sanne, how she found herself in tech, and her role at CodeSandbox.
The first language she entered the professional coding space with: Elixir, of course!
How she thinks about JavaScript now that she is proficient in another language like Elixir.
Learn more about CodeSandbox Projects and how it fosters live collaboration.
How the CodeSandbox app is broken down into Elixir, TypeScript, and Rust.
Why Sanne views CodeSandbox as a polyglot environment, but she isn’t a polyglot herself.
Find out why she prefers to stick with Elixir in her personal capacity.
Code BEAM Europe 2022 and some highlights from Sanne’s upcoming keynote address.
Top tips for helping juniors succeed at your organization; model asking questions.
The TLDR summary of garbage collection in Elixir from Sanne’s 2020 Code BEAM Talk.
Cute avatars over headshots, Sanne’s crafty hobbies, side projects, and more!
Some of the cool work taking place at the intersection of code and sewing.
Opportunities at CodeSandbox to dive into different codebases and learn different things.
Final plugs, mentions, and where to connect with Sanne!

Links Mentioned in Today’s Episode:

Sanne Kalkman on LinkedIn — https://www.linkedin.com/in/sannekalkman/
Sanne Kalkman on GitHub — https://github.com/sannek/sketch
Sanne Kalkman on Twitter — https://twitter.com/sannekalkman
CodeSandbox — https://codesandbox.io/
Our Flag Means Death — https://www.hbomax.com/series/urn:hbo:series:GYf3LzwJV98JifQEAAAAO
Walibi Amusement Park — https://www.walibi.com/
Code BEAM Europe 2022 — https://codesync.global/conferences/code-beam-sto-2022/
Sanne Kalkman: ’Who Takes Out Your Trash’ (Code BEAM V 2020) — https://youtu.be/OSdaXNQ0xhQ
Covatar — https://covatar.com/
FreeSewing — https://freesewing.org/
SmartLogic — https://smartlogic.io/
SmartLogic Jobs — https://smartlogic.io/jobs

Special Guest: Sanne Kalkman.

Cassidy Williams and Tobi Pfeiffer on Elixir Programming at Remote

podcast@smartlogic.io (SmartLogic LLC) — Thu, 28 Apr 2022 08:00:00 -0400

This double guest episode features Cassidy Williams, Head of Developer Experience and Education and Tobi Pfeiffer, Staff Engineer from Remote. This fast growing Elixir company provides HR support to clients who are hiring internationally. In this fascinating fast-paced conversation Cassidy and Tobi discuss how Remote works, the explosive growth it has seen and what Cassidy and Tobi have most enjoyed in their time there. Also, we learn more about Cassidy's content creation projects, why Tobi's handle is PragTob, and the strangest laws they have come across when working internationally. We also learn about Cassidy's love of mechanical keyboards and about Tobi's adorable pet rabbits. We wrap up the episode with some great book recommendations and what's upcoming at Remote.

Key Points From This Episode:

Welcome to Cassidy Williams (Head of Developer Experience and Education) and Tobi Pfeiffer (Staff Engineer) at Remote.
Why Cassidy recommends the app Centered for achieving flow state.
How different types of music affect everyone’s concentration while coding.
Getting to know Tobi: Rails Girls community member, wearer of green and keyboard player.
Who Cassidy is: a dweeb who likes memes and how she found the world of coding.
What Remote is and how it works.
How Tobi came up with the handle PragTob!
The explosive growth Remote has seen, and how they stay on top of it.
What's coming on the open-source front of Remote.
The challenges Remote faces when employing people from different countries.
The strangest laws Tobi and Cassidy have come across internationally.
Why Cassidy enjoyed the well-practiced onboarding aspects of Remote, and the company values Tobi most appreciates.
Tobi’s secret role in the formation of Remote!
The people Tobi and Cassidy see moving into Elixir and which skills benefit them the most.
Why Tobi's GitHub picture has a rabbit and his favorite game.
Cassidy’s passion for mechanical keyboards!
Book club recommendations: the books you should be looking out for, and why!

Links Mentioned in Today’s Episode:

Cassidy Williams on LinkedIn — https://www.linkedin.com/in/cassidoo/
Cassidy Williams on TikTok — https://www.tiktok.com/@cassidoo
Cassidy Williams’ Newsletter — https://cassidoo.co/newsletter/
Tobi Pfeiffer on LinkedIn — https://www.linkedin.com/in/tobiaspfeiffer
Tobi Pfeiffer on GitHub — https://github.com/pragtob
Remote — https://remote.com/
Remote GitHub — https://github.com/remoteoss
Centered — https://www.centered.app/
Benchee — https://elixirschool.com/en/lessons/misc/benchee
SimpleCov — https://github.com/simplecov-ruby
Rails Girls Berlin — http://railsgirls.com/berlin
The Agile Samurai: How Agile Masters Deliver Great Software — https://www.amazon.com/Agile-Samurai-Software-Pragmatic-Programmers
Netlify — https://www.netlify.com/
Devs for Ukraine — https://www.devsforukraine.io/
Jose Valim — https://www.linkedin.com/in/josevalim
Marcelo Lebre — https://www.linkedin.com/in/marcelolebre
RubyConf — https://rubyconf.org/
Rust — https://rust.facepunch.com/
Go — https://go.dev/
Node.js — https://nodejs.org/en/
React — https://reactjs.org/
Astro — https://astro.build/
Supabase — https://supabase.com/
Thea 2: The Shattering — https://store.steampowered.com/app/606230/Thea_2_The_Shattering
Mechanical Keyboard — https://en.wikipedia.org/wiki/Model_M_keyboard
QMK Firmware — https://docs.qmk.fm/#/
Brandon Sanderson — https://www.brandonsanderson.com/
Dark Matter — https://www.amazon.com/Dark-Matter-Novel-Blake-Crouch
SmartLogic — https://smartlogic.io/
SmartLogic Jobs — https://smartlogic.io/about/jobs

Special Guests: Cassidy Williams and Tobi Pfeiffer.

Devon Estes on The Power of Functional Programming

podcast@smartlogic.io (SmartLogic LLC) — Thu, 21 Apr 2022 08:00:00 -0400

Today’s guest is Devon Estes, who leads the third-party integration team at Remote, a company that uses technology to make it easier for other companies to hire remote employees (not contractors, actual employees) from over 100 countries across the world. Prior to working at Remote (which he loves, as you'll hear today), Devon was a freelancer and avid public speaker, and some of his talks from many years ago are still relevant today. In this conversation, Devon explains why functional programming is easier to use than any other programming type, and how the only thing holding you back from becoming a master is your desire to learn!

Key Points From This Episode:

Guest host Dan Ivovich explains what prompted him to come up with the theme for this season; Elixir in a Polyglot Environment.
A brief rundown of Devon’s daily life.
Content that Devon covers in the talks that he gives these days.
Devon explains what his role at Remote (where he has worked since November 2021) involves.
A challenge that Devon has noticed other people facing when learning Elixir.
An overview of what Remote does, and the specific area that Devon’s team focuses on.
Functional programming versus object-oriented programming.
Devon shares an example of the power of Elixir.
The importance of libraries in making Elixir a viable language for data scientists.
Devon’s thoughts on mutation testing.
Why Devon doesn’t do a lot of open-source work anymore.
How Remote has grown over the past year and a half.
One of the things that Devon loves about working at Remote.

Links Mentioned in Today’s Episode:

Devon Estes on Twitter — https://twitter.com/devoncestes
Devon Estes — https://devonestes.com/
Refactoring Elixir — https://www.youtube.com/watch?v=tJJMrtJEK1A
Going Multi-Node with ExUnit— https://www.youtube.com/watch?v=elC_8PhWRTg
Designing Elixir Systems with OTP — https://www.goodreads.com/book/show/45159167-designing-elixir-systems-with-otp
ElixirConf EU — https://www.elixirconf.eu/
Remote — http://remote.com/
SmartLogic — https://smartlogic.io/
Jobs at SmartLogic — https://smartlogic.io/jobs

Special Guest: Devon Estes.

Miguel Cobá on Deploying in Elixir and Other Languages

podcast@smartlogic.io (SmartLogic LLC) — Thu, 14 Apr 2022 08:00:00 -0400

Welcome to the new season of Elixir Wizards: Elixir in a Polyglot Environment. To get things going on this exciting and intriguing subject we are very happy to welcome Miguel Cobá! Miguel currently works at Shore, and he gives us some great insight into the part that Elixir plays at the company (alongside other languages), and how this suits his particulars skillset and vision. In this season, we want to consider important questions about reaching beyond the confines of the Elixir community, and how we can all learn from each other. Miguel is such a perfect guest to open this conversation, as he is fascinated by the way Elixir can fit into a network of knowledge and its deployment into other areas. In today's chat, we also get into the early days of Miguel's interest in programming, and how it took starting a job for him to really start learning. So, to hear all this and more, and to get a taste of a great season to come, be sure to tune in!

Key Points From This Episode:

Miguel's perspective on the importance of using Elixir alongside other languages.
The languages that Miguel has worked in, and currently uses.
A look at the path that Miguel took into programming and the first language he used!
Turning an interest into a career; Miguel's biggest periods of learning.
Background and motivations for Miguel's book, 100 Elixir Tips.
The book that Miguel wrote that aims to help developers to write their own books!
Constant learning and the passion that Miguel has for sharing this process with others through writing.
Miguel shares some surprising parts of deployment in other languages.
The combinations of languages that Miguel prefers.
An explanation of Elixir's strength for background or asynchronous tasks.
Why Miguel values the attitude above different language skills in a programmer.
Unpacking how Elixir fits into the polyglot environment at Shore.
How Miguel feels about community building and the usefulness of Twitter.
Miguel compares his favorite parts of Elixir and the things he feels it is missing.
Where to find and connect with Miguel online!

Links Mentioned in Today’s Episode:

100 Elixir Tips — https://store.miguelcoba.com/l/100elixirtips
Deploying Elixir — https://blog.miguelcoba.com/deploying-elixir-ebook
Miguel Cobá on Twitter https://twitter.com/MiguelCoba_
Elm — https://elm-lang.org/
Miguel Cobá Blog https://blog.miguelcoba.com/
Gumroad — https://gumroad.com/
Hashnotes — https://www.hashnotes.app/
Shore — https://www.shore.com/en/
SmartLogic — https://smartlogic.io/
Jobs at SmartLogic – https://smartlogic.io/jobs

Special Guest: Miguel Cobá.

Todd Resudek on the Impact of Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 03 Feb 2022 06:00:00 -0500

Welcome to the Season 7 finale! Today, we are joined by Todd Resudek, Staff Engineer at Jackpocket, to reflect on the past season and speak about the impact of Elixir, as well as a variety of other topics almost entirely unrelated to programming! Todd is a reformed graphic designer that got his start in web development 15 years ago. He has made a career in front-end development, PHP, Rails, and Elixir. He is also a member of the Hex core team and, in his spare time, he tinkers with hardware projects. In today’s episode of Elixir Wizards, you’ll learn more about the 2022 EMPEX Elixir Mountain event that Todd is co-organizing, the formula for anticipating how many people will turn up at your event, and what trains have to do with the history of timezones. We also touch on Todd’s hopes for the future of Elixir, how Elixir has impacted him, both personally and professionally, and why he recommends learning Elixir as a backup language, plus so much more! Tune in today for a fun discussion with Todd Resudek!
**
Key Points From This Episode:**

The hilarious and sometimes tragic mispronunciation of our names.
Learn more about the 2022 EMPEX Elixir Mountain event that Todd is co-organizing.
Todd shares a bit about his background and his allegiance to Wisconsin football.
We discuss the formula for how many people to expect at your meetup (or wedding).
Some interesting history on timezones and how they relate to trains.
Dune memes, roller skating, a qualifier for couple skates, and more.
Todd shares his favorite Elixir Wizards episode from Season 7: Brooklyn Zelenka.
How Todd learned Elixir when he first started working at Weedmaps.
Why he suggests learning Elixir as a ‘backup language’ rather than a primary one.
His biggest hope for the future of Elixir: an even more diverse, welcoming community.
How a functional programming language like Elixir has impacted the way Todd works.
The personal impact the Elixir community has had for Todd by enabling new connections.
Find out why Alex’s dog, Bean, loved the test kitchen at their previous workplace.
Eric and Alex share how the impact of Elixir has changed for them throughout this season.
What all our children, human and animal, had for breakfast.

Links Mentioned in Today’s Episode:

Todd Resudek on LinkedIn — https://www.linkedin.com/in/toddresudek/
Todd Resudek on Twitter — https://twitter.com/sprsmpl
Todd Resudek on GitHub — https://github.com/supersimple
Todd Resudek — https://supersimple.org/
Jackpocket — https://jackpocket.com/
EMPEX Conference — https://www.empex.co/
EMPEX MTN 2022 — https://www.empex.co/mtn
Alex’s Favorite Dune Meme — https://i.kym-cdn.com/photos/images/facebook/002/234/162/d96
‘Brooklyn Zelenka and The Exciting World of Edge Computing’ — https://smartlogic.io/podcast/elixir-wizards/s7e9-zelenka/
Toucan — https://www.toucan.events
Elixir Wizards |> Conference — https://smartlogic.io/about/community/elixir-wizards-conference/
SmartLogic — https://smartlogic.io/
Audience Survey -- https://smr.tl/survey

Special Guest: Todd Resudek.

Arthi Radhakrishnan on the Value of Collaborative Learning for Software Engineers

podcast@smartlogic.io (SmartLogic LLC) — Thu, 27 Jan 2022 06:00:00 -0500

This week we welcome Arthi Radhakrishnan back to the show to discuss how Elixir and her career more broadly have shaped her perspectives on learning. Arthi first got into programming as a child growing up in the Bay Area, constantly exposed to tech and tech culture. She remembers building websites using GeoCities in high school and learning about data structures and OOP in Java while in college before transitioning to Elixir during her current position as a backend engineer at Community. We hear about what made her learning so enjoyable, the biggest paradigm shifts she needed to make, and she talks about the value of mentorship, pair programming, and working at a company that encourages learning on the job. In today’s show, we also explore a realization that Arthi has come to at the end of her first decade as a software engineer: that effective learning requires a big dose of self-compassion. So, for all this and more, be sure to tune in today!

Key Points From This Episode:

Introducing Arthi and the work she does as a backend engineer for Community.
What it was like growing up in the Bay Area and how Arthi got into programming.
Going from building websites with GeoCities in high school to building a compiler in college.
The big role that Java and OOP played in Arthi’s experience of programming fundamentals.
Arthi’s experience of learning Elixir and having to shift away from an OOP paradigm.
Where Arthi is in her journey of learning Elixir and why she enjoys it so much.
How compelling it is to learn on the job and the value of companies that allow for this.
The impact that company culture has on job experiences and career trajectories.
Summer internships Arthi did in college and how they shaped her career goals.
Finding time to do personal learning and why Advent of Code is so helpful.
Why setting low expectations for yourself is a helpful paradigm for learning.
Exercising self-compassion while learning and how Arthi’s learning approach has evolved.
Why Arthi is so grateful that she has gotten to learn Elixir at Community specifically.
What good mentorship looks like to Arthi and why she loves pair programming.
How learning Elixir and the past 10 years have shaped Arthi’s sense of her needs.
Arthi’s thoughts on how Elixir will evolve in the next 10 years.

Links Mentioned in Today’s Episode:

Arthi Radhakrishnan — https://www.linkedin.com/in/arthiradhakrishnan/
Community — https://www.community.com/
Advent of Code — https://adventofcode.com/
SmartLogic — https://smartlogic.io/
Audience Survey -- https://smr.tl/survey

Special Guest: Arthi Radhakrishnan.

Meryl Dakin on Changing Lanes and Switching Gears With Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 20 Jan 2022 06:00:00 -0500

Today we welcome software engineer Meryl Dakin to the show, who is currently employed by Knock. Meryl is here to help us continue our exploration of this season's theme of the impact of Elixir, and we get to hear about all how it has impacted her professional and personal life! Our guest talks about her journey through the world of development and the different positions she has held before her current role. We also get into her recent stint as the emcee of ElixirConf alongside our other friend Sophie DeBenedetto! We talk about learning through teaching, encouraging more questions, and why Elixir has had such a positive impact on Meryl's approach to code more generally. Big takeaways from today's conversation include the way that learning a new language can alter one's career in multiple and unexpected ways, why the Elixir community can feel so safe and supportive, and who might get the most benefit from being exposed to Elixir at the right time. So, to hear it all from Meryl and our usual cast of characters, be sure to listen in!

Key Points From This Episode:

A quick update on Meryl and what she has been busy with lately.
Meryl's experiences emceeing the recent ElixirConf!
Unpacking what Knock does and who the company serves.
How Elixir has been used at Knock and the great experience Meryl has had building with it.
Meryl's learning curve with Elixir and the biggest developments in the space from her perspective.
The most common advice that Meryl would offer to junior engineers!
Why teaching is often the best route to further learning; Meryl's reflections on her presentations.
The importance of asking questions and speaking up when you do not understand.
How Elixir shifted Meryl's way of thinking about programming: cleaner code and encapsulation.
The different kinds of developers that might benefit from being introduced to Elixir.
Thoughts on making Elixir more visible to the right people in the larger community.
The personal impacts that Elixir has had on Meryl's life: meeting great people and finding an engaging and supportive community.
When to consider using Knock and the initial offer for new clients.
Where to go to find out more about Knock and whether it might be right for you!
Meryl shares her biggest hopes and dreams for the future of the Elixir community.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Meryl Dakin on Twitter — https://twitter.com/meryldakin
ElixirConf — https://www.elixirconf.com/
Netflix Christmas Universe — https://collider.com/netflix-christmas-universe-how-movies-connect-explained/
Flatiron School — https://flatironschool.com/
Frame.io — https://www.frame.io/
Knock — https://knock.app/
Knock on Twitter — https://twitter.com/knockdotcom
Knock Changelog — https://knock.app/changelog
Sophie DeBenedetto — https://www.amazon.com/Books-Sophie-DeBenedetto/s?rh=n%3A283155%2Cp_27%3ASophie+DeBenedetto
The Flutter Apprentice Book — https://www.raywenderlich.com/books/flutter-apprentice/v1.0.ea2
EMPEX — https://www.empex.co/mtn
Programming Phoenix LiveView — https://pragprog.com/titles/liveview/programming-phoenix-liveview/
Twilio — https://www.twilio.com/
Audience Survey -- https://smr.tl/survey

Special Guest: Meryl Dakin.

Brooklyn Zelenka and The Exciting World of Edge Computing

podcast@smartlogic.io (SmartLogic LLC) — Thu, 13 Jan 2022 06:00:00 -0500

We are very excited to welcome Brooklyn Zelenka back to the podcast to talk about her work at Fission and the ever-expanding frontier of edge computing! Brooklyn is a co-founder and CTO at Fission and she gives us some insight into the focus of the company's applied research. We hear from our guest about the projects she has been most excited about recently and she even talks about her newfound passion for fermentation! She does a great job of explaining why edge computing is potentially so revolutionary and some of the hurdles that are yet to be overcome on the way to reaching this potential. We discuss security and trust, tech equity, broad adoption, and much more before getting into some more Elixir-focused questions. Our guest shares how Elixir and functional programming have inspired her in different ways, as well as her perspective on some of the weaknesses of Elixir. At the end of our chat, Brooklyn gives some great resource recommendations for anyone wanting to learn more about edge computing, so make sure to stay tuned for that!

Key Points From This Episode:

What Brooklyn has been keeping busy with recently.
A little about Fission and what their research focuses on.
Tech and societal trends through the pandemic and Brooklyn's new interest in fermentation.
Brooklyn unpacks the main mission of edge computing and some of the biggest challenges.
Decisions around what is localized and what is stored remotely in edge computing.
Addressing the issue of trust and safeguarding against data breaches.
The influence of functional programming in Brooklyn's work on edge applications.
Some information on Brooklyn's talk at ElixirConf this year titled 'The Jump to Hyperspace.'
Our guest explains the concept of antientropy and its associated techniques.
Thoughts on the problem of tech equity and how this might be tackled.
Gaining popular trust for new technologies and their inevitable faults.
Brooklyn's feelings about Haskell, and the inspiration she takes from it into her work with Elixir.
The impact that Elixir has on Brooklyn's work in a broader sense.
The route that Brooklyn took into the functional programming world.
Brooklyn weighs in on the questions of Elixir's downsides.
Resources recommendations for anyone looking to get more acquainted with work in edge computing.
Where to find and connect with Brooklyn online!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Brooklyn Zelenka — https://twitter.com/expede?lang=en
Fission — https://fission.codes/
Brooklyn Zelenka at ElixirConf 2021— https://www.youtube.com/watch?v=ogOEEKWxevo
Designing Data-Intensive Applications — https://www.bookmall.co.za/products/designing-data-intensive-applications?gclid=Cj0KCQiA2ZCOBhDiARIsAMRfv9ITE1sFKIIcSwK6EGR04aW2RrFZphwrvDQxZekyhuPbEyuqKt6Td8QaApPqEALw_wcB
Brooklyn's Tepache Fermentation Recipe — https://ipfs.io/ipfs/bafybeiawn23o6prk4kdhv4cpbfylzr5g2fr22umhvbshf4rlksfrgjzpga/p/Tepache.pdf
Witchcraft Suite of Libraries in Haskell/Elixir — https://hexdocs.pm/witchcraft/readme.html
Proto School — https://proto.school/
Fission Discord — https://discord.gg/zAQBDEq
Fission Discourse — https://talk.fission.codes/
Fission on Luma — https://lu.ma/community/com-XuESjPQQHjh43pc
FissionCodes Twitter — https://twitter.com/FISSIONcodes
Witchcraft Suite — https://github.com/witchcrafters

Special Guest: Brooklyn Zelenka.

Sigu Magwa on the Elixir Community in Kenya

podcast@smartlogic.io (SmartLogic LLC) — Thu, 06 Jan 2022 06:00:00 -0500

We are always excited to have conversations about the growth of the Elixir community, and today we go truly global, welcoming Sigu Magwa to the podcast, who hails from Kenya! Sigu is currently traveling in the US and he fills us in on some of the highs and lows of his trip and why he is so excited to get home to his friends and family. From there, we get into some interesting information about Elixir Kenya and the growth of the meetup over the last couple of years. Sigu shares some insight into IoT in his country and what the general tech space is like right now over there, before opening up about his journey into programming and how he found his way into working with Elixir. We also get to talk about his company, Podii, and their first few years working with clients. Apart from all the tech talk, Sigu is kind enough to shed some light on Kenya's matatu buses, and what makes them so unique, a subject that was particularly captivating to our panel! Listeners can also expect to hear about the recent ElixirConf Africa, Sigu's thoughts on hiring young talent, and what he hopes to see in the next decade within the community. So to catch it all, be sure to listen in with us on Elixir Wizards!

Key Points From This Episode:

Sigu's trip to the US and the sights he has been seeing in different cities.
Some information from Sigu about the Elixir Kenya meetup and the community there.
Sigu's experiences with IoT technology in Kenya and its adoption.
The elevator pitch for Sigu's company, Podii, and its roots in training.
Podii's current operation and company size and some of the projects they have worked on thus far.
The coding language trends in Kenya; Sigu weighs in on what he has noticed.
Sigu's history in the programming space and how he made his way into the world of tech.
How 'matatu' buses operate in Kenya; TVs, celebrity portraits, strobe lights, and high speeds!
The ElixirConf Africa that was hosted this year and Sigu's experience of being involved.
Sigu's hopes for the Elixir community for the next ten years!
Approaches for identifying talented young Elixir developers.
How and where to connect with Sigu online and final remarks from our guest.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Sigu Magwa on LinkedIn — https://www.linkedin.com/in/sigu/?originalSubdomain=ke
Sigu Magwa on Twitter — https://twitter.com/s_igu
Podii — https://podiihq.com/
Nerves — https://www.nerves-project.org/platform.html
ElixirConf Africa — https://elixirconf.africa/
QuadBlockQuiz — http://quadblockquiz.org:4000/
Matatu Bus — https://www.theguardian.com/world/gallery/2018/apr/27/a-minibus-ride-like-no-other-nairobis-matatu-culture-in-pictures
Hire Junior Engineers — https://smartlogic.io/blog/hire-junior-engineers/
Teach Yourself Computer Science — https://teachyourselfcs.com/
Structure and Interpretation of Computer Programs — https://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
Elixir Wizards Discord — https://discord.com/invite/JGcqSaYf2a

Special Guest: Sigu Magwa.

Casting Spells with Brooklin Myers

podcast@smartlogic.io (SmartLogic LLC) — Thu, 16 Dec 2021 06:00:00 -0500

Brooklin Myers is on a quest to change the perception that Elixir is difficult to get into and we are so grateful to have him as a guest on the show today. Aside from being a passionate programmer, Brooklin spends a lot of his time trying to encourage new members in the Elixir community through his Twitter account and podcast called Elixir Newbies. In this episode, we talk to Brooklin about his relationship with Elixir and its broader community, why he loves the space so much and, and why he wants to help it grow. We cover his journey into programming and how he got involved with Elixir specifically. He talks about the features of the language that he loves most and how learning Surface has allowed him to use Elixir in the same way he used to use React. Our conversation also ventures onto the subject of Dungeons and Dragons, another passion of Brooklin’s, and he tells us how learning programming is the closest he has come to fulfilling his dream of being a wizard!

Key Points From This Episode:

Region-specific spelling and our peeves about words we easily misspell.
Brooklin’s background in React and how Surface has helped him use Elixir in a similar way.
Structure and testing: Why Brooklin loves Elixir and how it compares to JavaScript.
How Brooklin got into programming and left his job selling computers.
What led Brooklin to discover Elixir and how he realized its true potential.
The aspect of problem-solving and continuous growth Brooklin loves about programming.
Brooklin’s desire to help others learn and why he started the Elixir Newbie podcast.
How to get over perfectionism: the value of remembering it is okay to fail.
Sundi and Brooklin’s approach to taking notes and turning them into posts or tweets.
How Brooklin handles his writing, podcasting, and other work by time-blocking.
Brooklin’s love of Dungeons and Dragons and the improvisation of being the DM.
Why Brooklin loves fantasy and how programming is the closest thing to real-world magic.
The impacts of Elixir on Brooklin and how supportive the community has been to him.
Whether Brooklin feels that learning Elixir has changed the way he codes.
Aspects of Elixir that can improve regarding ease of access to the community.
Final shoutouts from Brooklin and where to connect with him online.

Links Mentioned in Today’s Episode:

Brooklin Myers on Twitter — https://twitter.com/brooklinjmyers
Elixir Newbie — https://www.elixirnewbie.com/
Elixir Newbie Podcast — https://podtail.com/en/podcast/elixir-newbie/
Lost Mines of Phandelver – https://www.dicebreaker.com/games/dungeons-and-dragons-5e/deal/lost-mines-of-phandelver-adventure-free
Kealy Doyle — https://www.linkedin.com/in/kealy-doyle/
Jono Stiansen — https://twitter.com/JonoCodes
Matthew Baker — https://www.linkedin.com/in/mcbii/
Anton’s Pasta Bar — https://antonspastabar.com/
Keith Eats Everything — https://www.youtube.com/playlist?list=PL9qQXSjI-WOppp4B9x5bgsBS3993KAX2e
Surface — https://hexdocs.pm/surface/Surface.html
SmartLogic — https://smartlogic.io/

Special Guest: Brooklin Myers.

Speedcubing and Building Livebook with Jonatan Kłosko

podcast@smartlogic.io (SmartLogic LLC) — Thu, 09 Dec 2021 06:00:00 -0500

It is important to us that the Elixir community keeps thriving, and one of the best ways to ensure this is by lowering the barrier to entry as much as possible. Livebook is helping to achieve this aim, and today we are lucky enough to be joined by its developer, Jonatan Kłosko. Jonatan is a young prodigy because while he is still at college, he is working closely with José Valim at Dashbit, and he can solve a Rubik’s cube in under five seconds! After hearing about his college thesis on evolutionary algorithms using Numerical Elixir, we jump into the story of how he met José and started building Livebook. He explains that Livebook is a web application for writing interactive and collaborative code notebooks for Elixir and we hear about the many features he is building into it. From there, Jonatan describes what he loves about Elixir, and we discuss how learning functional programming changes the way we code. Tuning in, you’ll also hear about a bunch of features that make Elixir so great, how its downsides are mostly solved by its extensibility, and some of Jonatan’s other hobbies that help him keep balance in his life. Be sure to sip on some Elixir with us today!

Key Points From This Episode:

Jonatan speaks about “speedcubing”: his hobby of quickly solving Rubik’s cubes.
How Jonatan got into programming and where he is at in his CS degree.
Discussing Jonatan’s Bachelor’s thesis project on evolutionary algorithms in Elixir.
How evolutionary algorithms are a style of solving optimization problems biologically.
Building the project using the Erlang distribution and the Numerical Elixir library.
How Jonatan started working on the Livebook project with Dashbit.
Thoughts on how Jonatan broke into the Elixir community and how others can do the same.
Livebook: a code notebook application with collaborative and sequential evaluation features.
The IEx session abilities of Livebook and how impressed Sundi was when she discovered them.
The different use cases for Livebook and the direction Jonatan wants to take the app in.
Jonatan’s process of learning Elixir at college and the application he built for a project.
The pair programming features of Livebook and how to use them.
How well-positioned Jonatan is to learn Elixir and what he loves about the language.
The functional programming style and how it affects how people write code after learning it.
Downsides of Elixir around immutability and typing and Jonatan’s feelings toward this.
How Elixir is making an impact on the programming community through being user-friendly.
Jonatan talks about his other hobbies and how he finds balance in his life.
Hopes for the future of Elixir, resources for learning, and how to get involved in the community.
How amazing the pipe operator is and the huge advantage it gives Elixir over JavaScript.
Final plugs from Jonatan and how best to reach out to him online.

Links Mentioned in Today’s Episode:

Jonatan Kłosko — https://jonatanklosko.com/
Jonatan Kłosko on GitHub — https://github.com/jonatanklosko
Speedcubing — https://www.rubiks.com/en-us/speed-cubing
Erlang Ecosystem Foundation Slack — https://erlef.org/slack-invite/erlef
Numerical Elixir — https://github.com/elixir-nx
LiveView — https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
Phoenix LiveView — https://github.com/phoenixframework/phoenix_live_view
Dashbit — https://dashbit.co/
Haskell — https://www.haskell.org/
React — https://reactjs.org/
Elixir — https://elixir-lang.org/
José Valim — https://twitter.com/josevalim
Livebook — https://dashbit.co/blog/announcing-livebook
SmartLogic — https://smartlogic.io/

Special Guest: Jonatan Kłosko.

Protocols in Elixir with Yiming Chen

podcast@smartlogic.io (SmartLogic LLC) — Thu, 02 Dec 2021 06:00:00 -0500

Today on the show we are grateful to get the chance to speak with Yiming Chen from Tubi, where we hear all about how he likes to use Elixir and the contributions he has made to the community. We begin as always with Yiming's journey into programming and how he got into Elixir through his early interest in Ruby. From there, we talk about the magic of Protocols, hearing about an awesome project Yiming built using them and how this lead him to build a testing framework called Promox. In this section, we also get into how Protocols enable polymorphic logic, why they are useful for defining shared interfaces explicitly, and the differences between Promox and Mox. Our conversation today covers some general advantages of writing code in Elixir, and we explore how it has influenced Yiming’s style of programming, its efficiency thanks to concurrency, and its usefulness for building maintainable applications. Wrapping up, we hear Yiming’s thoughts about the nascent Elixir community in China and all the future possibilities for this magical language.

Key Points From This Episode:

How Yiming got into programming by building websites using WYSIWYG tools as a child.
Yiming’s experiences using Ruby and how that led him to learn Elixir.
People Yiming knows that are using Elixir for personal projects and some highlights of these.
Yiming’s project where he used Protocols to transfer files from one cloud provider to another.
How Yiming’s Protocol project led him to create a testing framework called Promox.
Protocols versus behaviors and how Promox differs from Mox.
A basic description of how Protocols enable polymorphic logic in Elixir.
Why Protocols are so useful for defining shared interfaces explicitly.
The thing that makes Protocols in Elixir specifically attractive.
Sundi’s talk on Mox and her thoughts on the pros and cons of using it.
How Yiming got into using Mox through Ruby and his thoughts on it.
The advantages of using Elixir over Ruby relating to concurrency and testing.
Networking and software developer jobs after remote work.
How Yiming’s ElixirConf talk went and the positive feedback he received.
Yiming’s feelings about Test Driven Development and how closely he follows it.
Learning Lisp in college and Yiming’s earlier experiences with functional programming.
How small the Elixir scene in China is and thoughts about how it should grow.
The benefits of Elixir for building maintainable applications and more.
How Elixir has changed the way the Yiming programs.
A model for building websites in Elixir with HTTP requests as functions.
Final plugs from Yiming about the need for developers at Tubi!

Links Mentioned in Today’s Episode:

Yiming Chen on Twitter — https://twitter.com/dsdshcym?lang=en
tubi.tv — https://tubitv.com/
Quinn Wilton — https://twitter.com/wilton_quinn
Promox — https://giters.com/dsdshcym/promox
Sundi Myint: Stunt Doubles | Testing with Mox, Elixir Conf 2021 — https://youtu.be/qMScnpGhu4E
Yiming Chen - Promox: Roles, Protocols, and Mocks — https://youtu.be/Df81LbdRd0A
‘Mocks and explicit contracts’ — https://dashbit.co/blog/mocks-and-explicit-contracts
Programming Phoenix — https://www.amazon.com/Programming-Phoenix-Productive-Reliable-Fast/dp/1680501453
Why Elixir Matters A Genealogy of Functional Programming - OsaGaius — https://youtu.be/X2u0bBqhRKE
SmartLogic — https://smartlogic.io/

Special Guest: Yiming Chen.

Learning and Teaching Functional Programming with Adolfo Neto

podcast@smartlogic.io (SmartLogic LLC) — Tue, 23 Nov 2021 06:00:00 -0500

Today we are joined by programmer, professor, educator, and podcaster, Adolfo Neto! We have a fascinating conversation that continues our exploration of the theme of the impact of Elixir, hearing from Adolfo about his early attraction to computers and computer science, the decision to study the subject, and how this led to a life in education and academia. We also talk about growing up in Brazil and how geography influenced his career trajectory, before getting into some of the main outlets that Adolfo uses to share information on functional programming. He also comments on what he loves about Elixir, why learning it can improve any programmer's skills, and much more. One of Adolfo's main goals with his podcasts and YouTube channel is the diversification of the computer science field, and to bring the subject to a wider audience that may not always consider it an option to pursue. Towards the end of our chat, our guest shares some thoughts on useful resources to check out, and his desire to help the Elixir community to continue to grow!

Key Points From This Episode:

Opening remarks and rants from Adolfo regarding Livebook!
Adolfo's route into teaching and how he became a university professor.
Information on Adolfo's Ph.D. program which he completed at the University of São Paulo.
The initial impetus to study computer science; what drew Adolfo to the field.
Adolfo's YouTube channels and the subjects he covers for his audience.
The course that Adolfo offers on Elixir to students all over the world!
How Adolfo found and learned about functional programming.
Adolfo's thoughts on the benefits of different functional programming languages.
The main goals that Adolfo has for his functional programming classes.
Adolfo's own forays into podcasting, and what drew him to the medium!
Experiences in the South; Adolfo's early days studying the US.
Recommended resources for learning Elixir; the books and sites that Adolfo uses.
Adolfo's hopes for Elixir to keep growing and why he prefers functional programming.
How to connect with Adolfo online and make use of some of his amazing content!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Adolfo Neto on Twitter — https://twitter.com/adolfont
Adolfo Neto on YouTube — https://www.youtube.com/c/AdolfoNeto
Livebook — https://livebook.dev/#install
Fly.io — https://fly.io/
BASIC — https://en.wikipedia.org/wiki/BASIC
ML (programming language) — https://en.wikipedia.org/wiki/ML_(programming_language)
Emílias on Twitter — https://twitter.com/emilias_utfpr
Elixir em Foco on Twitter — https://twitter.com/elixiremfoco
Seven Languages in Seven Weeks — https://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X
Clojure — https://clojure.org/
Laurie Williams — https://collaboration.csc.ncsu.edu/laurie/
Saša Jurić — https://www.theerlangelist.com/
Brujo Benavides on LinkedIn — https://www.linkedin.com/in/elbrujohalcon?originalSubdomain=es
Elixir School — https://elixirschool.com/en/
Exercism Elixir Track — https://exercism.org/tracks/elixir
Exercism Erlang Track — https://exercism.org/tracks/erlang

Special Guest: Adolfo Neto.

The Benefits of Consistently Growing Your Toolset with Florian Kraft

podcast@smartlogic.io (SmartLogic LLC) — Thu, 18 Nov 2021 06:00:00 -0500

As we continue this season of the podcast, focusing on the impact of Elixir, we are joined by Florian Kraft, all the way from Berlin, Germany! Florian works as a software engineer at Contentful, and has a number of exciting open-source projects that he is currently involved with. In our fun conversation with Florian, we get to hear about the events that led up to him becoming interested in computers and working with software, and why he maintains a light-hearted attitude when talking about his expertise. We also get to hear from our guest about his thoughts on a few other languages, and why learning new languages is a great way to constantly improve your work in the languages you already know! Florian talks about what drew him to Elixir and the community and also shares some of his reflections from this year's virtual Elixir Wizards conference. Towards the end of our chat, Florian tells us about his work with AdoptOSS and Mimicry, which you can currently find on GitHub, both of which we are quite excited about! So to hear it all from Florian and our usual suspects, be sure to listen in!

Key Points From This Episode:

Florian's interesting route into the world of software engineering.
How Florian views his experiences and skills as a software engineer.
Florian's thoughts on Haskell and some of the best resources for learning about it.
The languages that Florian uses in his work at Contentful.
Experiences entering into the Elixir community and the colleague who introduced him to the language!
Life in Germany and Berlin; thoughts on the seasons, and the general culture.
Florian's experiences at this year's Elixir Wizards conference; warming to virtual events.
Staying active in the Elixir community and Florian's honest confessions about the time he puts in.
Features that Florian misses and wishes for when working in Elixir.
Immutability and pattern matching: Florian's favorite parts of Elixir!
Some of the open-source Elixir projects that Florian is currently working on.
The video games that Florian has most enjoyed recently and some of his all-time favorites!
Where to find and connect with Florian and his exciting projects!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Florian Kraft — github.com/FlorianK
Contentful — https://www.contentful.com/
Exercism — https://exercism.org/
Adoptoposs — https://adoptoposs.org
Adoptoposs Github — https://github.com/adoptoposs/adoptoposs
Mimicry — https://github.com/mimicry-tech/mimicry
Learn You a Haskell for Great Good — https://www.amazon.com/Learn-You-Haskell-Great-Good/dp/1593272839
Haskell — https://www.haskell.org/
Prolog — https://www.cpp.edu/~jrfisher/www/prolog_tutorial/pt_framer.html
Learn You Some Erlang for Great Good — https://www.amazon.com/Learn-Some-Erlang-Great-Good/dp/1593274351
Elixir in Action, Second Edition — https://www.manning.com/books/elixir-in-action-second-edition
Gleam — https://gleam.run/
Autobutler — https://autobutler.co.uk
Squid Game — https://www.rottentomatoes.com/tv/squid_game
Oktoberfest — https://www.imdb.com/title/tt10244612/
Toucan — https://www.toucan.events/
The Binding of Isaac — https://store.steampowered.com/app/113200/The_Binding_of_Isaac/
Zelda — https://www.zelda.com/
Doom — https://bethesda.net/en/game/doom
Defragmenting C Drive — http://hultbergs.org/defrag/

Special Guest: Florian Kraft.

Re-Platforming One of the Original Dot Coms in Elixir with Angel Jose

podcast@smartlogic.io (SmartLogic LLC) — Thu, 11 Nov 2021 06:00:00 -0500

Today’s guest is Angel Jose, a Software Engineer Manager at Cars.com with a passion for product and the customer experience. Angel played a key role in completely re-platforming Cars.com via Elixir, Phoenix, and other open source tooling, and his former adventures in the blockchain space include working with ETH, EOS, and general distributed tooling. In today’s episode, we discuss Cars.com's decision to migrate to an entirely Elixir-based system, rebuilding the data model from scratch, redesigning all of the user interfaces, and what that meant for the team that Angel was tasked with leading, as well as how the Elixir system functions at such incredible scale, with Cars.com receiving more than a million visitors daily! We touch on Angel’s approach to onboarding new engineers, how Elixir impacts this process, and the broader impact Elixir has on the community as a whole, as well as what he hopes to see from the community in the future, so make sure not to miss this awesome conversation about adopting Elixir with Angel Jose!

Key Points From This Episode:

Hot takes, rants, and obsessions: Angel’s best and worst taco experiences.
Why Angel won’t be at ElixirConf 2021 and the story of how he began programming in Elixir.
The process of finding a job in software engineering after completing an online bootcamp.
Angel’s experience of navigating the freedom that comes with being an engineer.
Find out how Angel got involved in re-platforming Cars.com, one of the original dot coms.
Get a glimpse into the make up of the engineering team at Cars.com.
How the pandemic impacted not only Angel’s deadlines but the car industry as a whole.
The ETL pipeline of different data points that makes up Cars.com and Auto.com.
Angel shares his opinion of LiveView and what he has learned about using it at scale.
Advice for those adopting new technology: make sure there are enough resources out there.
Where Angel believes his team would be without Elixir and what they are looking forward to.
Some of the tangible benefits Cars.com has seen from flipping the switch to Elixir.
How Angel approaches onboarding new engineers by providing them with resources and integrating learning into their day-to-day.
The importance of celebrating small wins and fostering feelings of accomplishment.
Angel on how Elixir impacts onboarding and new engineers; more simplicity, less magic.
How Elixir has impacted the programming community and what Angel hopes to see in future.
Taco happy hour, conference food, making the most of each meal, remote work, and more!
What Angel has learned from working remotely, particularly from a social perspective.
Angel shares his dream car after working at Cars.com and moving to Colorado.

Links Mentioned in Today’s Episode:

Angel Jose on LinkedIn — https://www.linkedin.com/in/ajose01/
Angel Jose on Twitter — https://twitter.com/ajose01
Cars.com — https://www.cars.com/
Cars.com Careers — https://www.cars.com/careers/
Elixir Conf — https://2021.elixirconf.com/
Elixir Slack — https://elixir-slackin.herokuapp.com/
General Assembly — https://generalassemb.ly/
SmartLogic — https://smartlogic.io/

Special Guest: Angel Jose.

The Impact of Elixir Launchisode

podcast@smartlogic.io (SmartLogic LLC) — Thu, 04 Nov 2021 06:00:00 -0400

As we kick off our new, seventh season of the Elixir Wizards podcast, we wanted to introduce our theme of the impact of Elixir by having a simple chat between our panel and foregoing our usual guest format. As fans of podcasts ourselves, we always like to get to know some of the personalities behind the voices, so we decided to take this opportunity to do just that, with Alex, Sundi, and Eric! So to hear a little about what to expect in the coming weeks of the show, what the teams have been up to recently, both professionally and beyond, and to just enjoy a quick hangout with some friendly voices, make sure you tune into this launchisode!

Key Points From This Episode:

What our team has been up to recently: new projects, the apprentice program, and more.
Reflections on this iteration of the apprentice program and differences from 2018.
The recent ElixirConf and how our panel was involved in the event.
Inside information that is shared at conferences and learning about the world!
Avoiding the pressure to always do more while engaging in the community.
Noting the impact that Elixir has had on each of us, and how we write code respectively.
Proactive learning and career growth; looking forward to the new season exploring these subjects!
Staying focused on what's important, getting rest, and pursuing passions.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Aino — https://github.com/oestrich/aino
Aino Read Me — https://ainoweb.dev/readme.html
King Tooth — https://www.instagram.com/kingtooth_pug/
SmartLogic Apprenticeship Program — https://smartlogic.io/about/community/apprentice/
SmartLogic Welcomes Two New Developer Apprentices to the Team! — https://smartlogic.io/blog/2021apprentices/
Elixir Conf — https://2021.elixirconf.com/
Culttt — https://www.culttt.com/
Shrek — https://www.rottentomatoes.com/m/shrek
Kangaroo Jack — https://www.rottentomatoes.com/m/kangaroo_jack
Korn — https://www.kornofficial.com/
Flutter — https://flutter.dev/docs/resources/books
Lonestar Elixir — https://lonestarelixir.com/

Wrapping up BEAM Magic with Amos King

podcast@smartlogic.io (SmartLogic LLC) — Thu, 26 Aug 2021 06:00:00 -0400

We have reached the final episode of our season, and as we wrap up our exploration of BEAM magic, we are joined by Amos King, whose tweet was the inspiration behind this season's focus! We've had such a great time this season and hope that our listeners have enjoyed it as much as we have, and gained something in the process. Our conversation with Amos jumps around from exploring his experiences during the last year and a half, to the journey he has been on with his company, Binary Noggin, life as a CEO, and much more! We delve into some thoughts from our guest about the relationship between magic and understanding and also talk a little about this year's upcoming ElixirConf, where Amos will be speaking. Amos also shares how learning a new language can help the coding you do in languages you already know, and tells an interesting story about how he turned a long commute into a superpower! So stay tuned for Season 7, coming to you soon, and thank you for sticking with us this long!

Key Points From This Episode:

Looking forward to this year's ElixirConf and the hope that it will proceed.
Amos' return to the office after three months of working from home.
A little about Binary Noggin and the different size clients they work with.
The inspiration behind the company name and the transition from side work to a full-time gig.
Amos' experiences as a CEO during the pandemic and the surprising growth at Binary Noggin.
How Amos inspired the BEAM Magic theme for this season and his thoughts on understanding.
Amos' experiences of speaking at conferences and the possibility of presenting about magic.
Some details on Amos' talk this year at ElixirConf.
How Amos was introduced to Elixir through Erlang and the things that made him love it!
The impact that learning new languages can have on your work in general.
How an extremely long commute early in Amos' career served him in unexpected ways.

Links Mentioned in Today’s Episode:

SmartLogic Jobs — https://smartlogic.io/about/jobs
Amos King on Twitter — https://twitter.com/adkron
Binary Noggin — https://binarynoggin.com/
Binary Noggin Careers — https://binarynoggin.com/about-us/#careers
Binary Noggin Email — contact@binarynoggin.com
DirtyInformation — http://dirtyinformation.com/
Elixir Outlaws — https://elixiroutlaws.com/
Wallaby — https://github.com/elixir-wallaby/wallaby
Testing Elixir — https://www.goodreads.com/book/show/54156353-testing-elixir

Special Guest: Amos King.

Mini-Feature Extravaganza featuring Tyler Clemens, Elom Amouzou, Elise Navarro, and Jeremy Neal

podcast@smartlogic.io (SmartLogic LLC) — Thu, 19 Aug 2021 06:00:00 -0400

This episode serves as a round-up of some of the special mini-features we have recorded throughout Season 6, where we'll hear from Tyler Clemens, Elom Amouzou, Elise Navarro, and Jeremy Neal about their work and experiences with Elixir. Our first segment is with Tyler, who is a software developer at Jackpocket, where he explains what he is currently busy with and how the company is offering access to the lottery in more safe and convenient ways. We then move on to Elom, who talks about transitioning from a life in public education, and what prompted him to learn functional programming. Elise, who works at Zingeroo, takes us through her relatively new career, why she is so excited about Elixir, and the interesting work that is being done at her company to educate the public about the stock market. Lastly, Jeremy talks to us about the socially conscious agenda at Clover Food Lab, his personal interests in cooking and baking, and how he came to work with Elixir. All of our guests share helpful resources for learning, and reflections on their time working within Elixir - make sure to join us to catch all this good stuff!

Key Points From This Episode:

Tyler's path into software engineering and the first language he learned.
What Jackpocket offers its customers and how Elixir is used within the company.
Tyler's thoughts on the perks and challenges associated with engineering with Elixir.
The most helpful resources that Tyler uses when in need: Elixir Slack, books, and Elixir School!
Onboarding and training in Elixir and the biggest challenges presented in this area.
Tyler's passion for photography and imagining an alternative career path in this direction.
Elom's first programming language and the subsequent transition into Elixir.
How Elom moved into working in programming from his roots in education.
Elom's perspective on the positives associated with adopting Elixir early on.
Resource recommendations from Elom for early-stage developers.
Considering the pros and cons of the small intimate Elixir community and its future.
Elom's ideal alternative career path and favorite book!
Elise's beginnings in programming and her move from a career in digital media.
Comparing Elixir with other languages; Elise weighs in with her experiences.
What Zingeroo does and how they use Elixir to make the stock market more accessible through the app.
The benefits of using Elixir for a real-time app like Zingeroo.
The resources that have been most valuable to Elise since joining the community.
Elise's alternative career path, and her passion for teaching Pilates.
Jeremy's educational and professional path into software engineering and working with Elixir.
How Jeremy has been using LiveView in his work to get a functional UI up and running.
What Clover Food Lab does and how Elixir is used at the company and online store.
Jeremy's thoughts on a different career and why he would love to be a baker!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Tyler Clemens — https://www.linkedin.com/in/tylerclemens
Jackpocket — https://jackpocket.com/
Elixir in Action — https://www.goodreads.com/book/show/38732242-elixir-in-action
Elixir School — https://elixirschool.com/
Turing School — https://turing.edu/
Pragmatic Bookshelf — https://pragprog.com/
Code Flow Thinking Elixir — https://thinkingelixir.com/available-courses/code-flow/
Frantz Fanon — https://www.britannica.com/biography/Frantz-Fanon
Peau Noire, Masques Blancs — https://www.amazon.com/Peau-Noire-Masques-Blancs-French/dp/2020006014
Elise Navarro — https://www.linkedin.com/in/elise-navarro
Zingeroo — https://zingeroo.com/
Jeremy Neal — https://www.linkedin.com/in/jeremy-neal-59ba8b82
Clover Food Lab — https://www.cloverfoodlab.com/

Special Guests: Elise Navarro, Jeremy Neal, and Tyler Clemens.

Delving Deeper into Magic with Quinn Wilton

podcast@smartlogic.io (SmartLogic LLC) — Thu, 12 Aug 2021 06:00:00 -0400

Joining us on the show today is Quinn Wilton, and we have a wonderful conversation with our guest about her journey with Elixir, unusual path into programming, and her wide appreciation for different languages! We start off looking at the time Quinn spent at Waterloo University and what separates the Canadian ethos around computer science. From there, we turn to Quinn's early work in programming, the first proper job that she stepped into, and the immediate affinity she felt for working in Elixir. We also talk a bit about the interesting research that Quinn has been conducting privately, tracking and plotting the path of Erlang over the decades, while also reflecting on the skill of academic reading. We spend some necessary time hearing from Quinn about the BEAM and what BEAM magic means to her, before hearing about her website, love of Twitter, other languages that currently have her excited, and the avenues she is most lit up about exploring in the future! Listen in to hear it all, as we continue this journey!

Key Points From This Episode:

Quinn's reflections on her education in Canada, and differences to the American approach to computer science.
Reasons that Quinn wanted to pursue a career in programming
The first jobs that Quinn landed as a programmer; creating a Roblox game and tracking malware.
How Quinn was introduced to Elixir and the immediate love she felt for the language.
The recent work that Quinn has been busy with researching and tracing the history of Erlang.
Experiences of reading academic papers and what sets it apart from other formats.
The inspiration behind Quinn's website and her affinity for Twitter's format.
Quinn's favorite characteristics of the BEAM: the debugging possibilities.
The project that Quinn worked on using Gleam on the BEAM and her enjoyment of its simplicity.
Some possible areas, outlined by Joe Armstrong, that Quinn is excited to explore in the near future.
Quinn's huge appreciation for different programming languages and her fascination with Strand.
Encouragement from Quinn to dive into reading intimidating research papers.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/jobs
Quinn Wilton — https://quinnwilton.com/
Quinn Wilton on Twitter — https://twitter.com/wilton_quinn
Quinn Wilton on GitHub — https://github.com/QuinnWilton
University of Waterloo — https://uwaterloo.ca/
Roblox — https://www.roblox.com/
Lookout — https://www.lookout.com/
Clint Gibler — https://clintgibler.com/
Gleam — https://gleam.run/
Joe Armstrong — https://www.theguardian.com/education/2019/may/08/joe-armstrong-obituary
'Getting Erlang to talk to the outside world' — https://www.researchgate.net/publication/2549678_Getting_Erlang_to_talk_to_the_outside_world
Universal Binary Format — https://github.com/ubf/ubf
CLU — https://en.wikipedia.org/wiki/CLU_(programming_language)
Strand — https://en.wikipedia.org/wiki/Strand_(programming_language)

Special Guest: Quinn Wilton.

The Bridge Between Elixir and Zig with Isaac Yonemoto

podcast@smartlogic.io (SmartLogic LLC) — Thu, 05 Aug 2021 06:00:00 -0400

While NIFs provide a great way to interface with native code in the BEAM machine, the process can also be rather error-prone. Thankfully, since Isaac Yonemoto built Zigler, things have become a lot simpler, and he joins us today to talk about how. Isaac is an Elixir developer with a background in biotech and we kick off the discussion by hearing about his journey into programming and some of the ways that he has combined it with science. From there we hear more about the different languages Isaac has worked in and why he fell in love with Elixir, where he talks about its encouragement of test-driven development and how this has made him a better programmer. We dive right into the contributions Isaac is making to the Elixir community next, and he starts off by talking about Zigler. He explains how Zigler provides a bridge between Zig and Elixir that makes it far easier to build NIFs. We hear a bunch of the other cool possibilities that Zigler offers to Elixir as well, including its ability to make debugging easier by appending the Zig stack trace to the Elixir one. After hearing Isaac’s opinion of magic in Elixir, we close today's show off with a few of the other projects he is working on, contributions that are bound to make the world of Elixir even more exciting!

Key Points From This Episode:

Isaac’s early exposure to programming and how he got started in tech.
The education Isaac had in the sciences and his experience in the biotech sphere.
Difficulties with installing Ruby and how this led to Isaac learning Elixir.
Support for asynchronous testing and the reasons why Isaac finds joy in Elixir.
The emphasis on test-driven development in Elixir and how this has made Isaac a better programmer.
Isaac’s experiences with Zig and the similarities between it and Elixir.
How NIFs allow C code in Elixir and what it is like debugging them.
Isaac’s Zigler project and how it provides integration between Elixir and Zig making it easy to build NIFs.
Cross-compiling C using Zig and why Isaac built a disassembler.
Aspects of the BEAM that make it harder to write NIFs in Elixir than in Julia.
Isaac’s opinion of magic in programming and how it should always be comprehensible.
Final plugs from Isaac: where to find Zigler, and some upcoming projects.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Isaac Yonemoto on Twitter — https://twitter.com/DNAutics
Isaac Yonemoto on GitHub — https://github.com/ityonemo
Isaac Yonemoto on YouTube — https://www.youtube.com/channel/UCarZZW7eavljSdGRQx9kkSA
Selectrix — https://github.com/ityonemo/selectrix
Mavis — https://github.com/ityonemo/mavis
Chiaroscuro - https://github.com/ityonemo/chiaroscuro
Zigler - https://hexdocs.pm/zigler/Zig.html
Zigler on GitHub — https://github.com/ityonemo/zigler
Julia — https://julialang.org/
Testing Elixir with Jeffrey Matthias and Andrea Leopardi — https://smartlogic.io/podcast/elixir-wizards/s6e6-matthias-leopardi/

Special Guest: Isaac Yonemoto.

Maxim Fedorov on Building and Scaling WhatsApp with Erlang

podcast@smartlogic.io (SmartLogic LLC) — Thu, 29 Jul 2021 06:00:00 -0400

Today we are so excited to share a conversation with Maxim Fedorov, who is the Core Infrastructure Lead at communications giant, WhatsApp! In our chat, Maxim offers such interesting insight and wisdom from a long career in the space, focusing on Erlang and why he views it as such a powerful language for the work at WhatsApp. We also get some backstory from Maxim, looking at his first experiences with computers, his educational background, and some of the work he did leading up to his current position. Our guest does a great job of sharing his thoughts on what he sees as a lack of magic within the Erlang language, why he prefers this, and how the company has managed to scale in such a major way over the past years. We also deal with some more general questions, weighing functional languages against object-oriented ones, useful resource recommendations, and a whole lot more! We finish off this episode with a mini-interview with David Hardwick, who is the current Vice President of Engineering at STORD, so make sure to stay tuned until the end for that!

Key Points From This Episode:

The beginnings of Maxim's interest in computer science and software development.
How Maxim transitioned into the network security field.
Maxim's experience with timezones and how this is approached for an app like WhatsApp.
Thoughts on why WhatsApp is so popular outside of the United States.
How Erlang is used at WhatsApp to power messaging.
Probable reasons that Erlang was selected as the language for WhatsApp.
Outages and downtime; what constitutes a serious issue for WhatsApp user experience.
The massive growth that WhatsApp has seen and how their approach to scaling has evolved.
Characteristics of Erlang that make it so well suited to WhatsApp's needs; simplicity and reliability.
Maxim's perspective on the issues around programmer education and their results.
Functional languages versus object-oriented programming; Maxim's thoughts on strengths and weaknesses.
Why Maxim views Erlang as not containing or performing anything magical.
Maxim's recommendations for resources when getting started in Erlang!
Looking back at Maxim's experiences of tertiary education and the thesis he produced.
The scaling of the WhatsApp server; the project that Maxim is most proud of!
Maxim's love for motorcycles and bicycles and how these grew out of initial conveniences.
Today's mini-feature interview with David Hardwick, VP of Engineering at STORD.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Maxim Fedorov: https://au.linkedin.com/in/maxim-fedorov-14a570b
Electronika MK-61 — https://en.wikipedia.org/wiki/Elektronika_MK-52
Brian Acton — https://www.forbes.com/profile/brian-acton/
Learn You Some Erlang — https://learnyousomeerlang.com/
Adopting Erlang — https://github.com/adoptingerlang
Joe Armstrong Thesis — https://erlang.org/download/armstrong_thesis_2003.pdf
The BEAM Book— https://github.com/happi/theBeamBook
ejabberd — https://www.ejabberd.im/
Will Cathcart Tweet — https://twitter.com/wcathcart/status/1385253969522413568
Clarke's three laws — https://en.wikipedia.org/wiki/Clarke%27s_three_laws
Lukas Larson — https://twitter.com/garazdawi
Erlang OTP — https://github.com/erlang/otp/blob/master/lib/kernel/src/pg.erl
David Hardwick — https://www.linkedin.com/in/davidhardwick
STORD — https://www.stord.com/
BetterCloud — http://www.bettercloud.com/

Special Guest: Maxim Fedorov.

Chelsea Troy on the Importance of Access and the Impact of Teaching

podcast@smartlogic.io (SmartLogic LLC) — Thu, 22 Jul 2021 06:00:00 -0400

Some of you may recognize Chelsea Troy from her popular blog of the same name or as a keynote speaker for the March 2021 Code BEAM conference. Chelsea is an instructor in the Master's Program in Computer Science at the University of Chicago and currently works as a staff software engineer at Mozilla, where she specializes in machine learning and backend systems. In our conversation with Chelsea, we discuss some of the unique aspects of coding as a career. Chelsea outlines how programming can be more accessible than other careers because it doesn't have the same financial burden when it comes to education. She also emphasizes the importance of allowing a more diverse range of people access to the field and unpacks the type of person the internet was originally built for, explaining how it had favored privileged affluent individuals from the Bay Area. We hear from Chelsea about how she became a programmer out of a desire for job security rather than passion and why she believes it’s so important to have a broader representation of different narratives when it comes to careers in programming and coding. Later Chelsea shares the story of how she became an educator and why she is so passionate about teaching. For all this and much more, join us today!

Key Points From This Episode:

Introducing today’s guest Chelsea Troy
Why Chelsea believes it’s important to privilege multiple narratives of why people choose to pursue programming as a career.
There is less of a financial burden with becoming a programmer than other higher-paying professions.
The benefits of a diverse group of people having access to programming as a career.
What first prompted Chelsea to start her blog and how her goals for it have changed over time.
Why Chelsea struggles to give advice on how to market a blog.
How being able to draw parallels between different coding languages has strengthened Chelsea’s teaching and writing pursuits.
Why Chelsea is so enthusiastic about teaching.
How teaching allows Chelsea to have a more meaningful impact in the field of tech.
How Chelsea prioritizes which jobs and clients to pursue as a consultant.
How having two parents who taught for living influenced Chelsea’s passion for teaching.
Chelsea shares how she earned her position at Chicago University, despite expecting not to.
The challenges and benefits of teaching remotely.
The pros and cons of functional languages versus object-oriented languages.
How students tend to react to learning functional languages versus object-oriented languages.
Mini-feature segment: hear from Rosemary about how she became a software engineer.
How Rosemary built websites as a side hustle while studying English.
Rosemary shares how she transitioned from working with Java and Blu-ray discs to doing back-end web development and writing in Elixir.
How RentPath, the company Rosemary is currently working for, is transitioning from Ruby to Elixir.
An outline of RentPath and what they do.
Rosemary’s many hobbies and pursuits, including wildlife photography.

Links Mentioned in Today’s Episode:

Chelsea Troy on Twitter — https://twitter.com/HeyChelseaTroy
Chelsea Troy on LinkedIn — https://www.linkedin.com/in/chelseatroy/
Chelsea Troy Blog — https://chelseatroy.com/
Upcoming Code BEAM Conferences — https://codesync.global/
Chelsea Troy on Youtube — https://www.youtube.com/channel/UCIwpdjmSUJmqJ8HwvIGNqig
Ruby — https://www.ruby-lang.org/en/
Mozilla — mozilla.org/en-US/
Pocket — https://getpocket.com/
Rosemary Ledesma — https://www.linkedin.com/in/rosemary-ledesma-b6198717/
RentPath — https://www.rentpath.com/
RedFin — https://www.redfin.com/

Special Guest: Chelsea Troy.

Testing Elixir with Jeffrey Matthias and Andrea Leopardi

podcast@smartlogic.io (SmartLogic LLC) — Thu, 15 Jul 2021 06:00:00 -0400

While we can think of many reasons why we love Elixir, the community could always benefit from a more lively conversation around testing. It was with this in mind that Jeffrey Matthias and Andrea Leopardi decided to write Testing Elixir, and today they join us on the show to share some of the insights to be found in their new book. Our guests start by sketching out the main reasons why they decided to write a book of this nature before speaking to the process of writing it collaboratively from their respective homes in Italy and the US. Andrea and Jeffrey speak about the challenges of finding a middle ground between their unique styles to come up with a unified testing method. The conversation then takes a deep dive into the weeds of testing in Elixir and we hear our guests' perspectives on the most appropriate situations to use async true, Mox, Ecto Sandbox, and other techniques. We wrap up our interview with a question about what Andrea and Jeffrey would most like people to take away from their book where they express the hope that it can act as a springboard for further conversation about best practices for testing in Elixir and more. As always, we close the show off with our mini-interview, this time talking to Tracey Onim from Podii.

Key Points From This Episode:

Why Jeffrey and Andrea wrote their book and how they pitched it to the publisher.
How the feedback Andrea and Jeffrey got while writing the book shaped its content.
What writing the book was like considering its authors live in different countries.
How our guests came up with a unified testing method when each had their own style.
Stories about testing mistakes and the funny situations they led to.
Discussing the HBO integration test email and how it was responded to and dealt with.
The issue of developers not using async true enough and how to get better at it.
When to use async true, Ecto Sandbox, and Mox.
Why our guests use Mox, when the best times to use it are, and how it shapes your thinking.
Exploring the relationship between test driven development and using the program.
What can go wrong if you rely purely on tests to test out your code.
The main takeaways our guests hope can be found in their book.
Final plugs from Jeffrey and Andrea and where to find them online.
A quick interview where we learn more about Tracey Onim from Podii.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Jeffrey Matthias on Twitter — https://twitter.com/idlehands
Andrea Leopardi — https://andrealeopardi.com/
Andrea Leopardi on Twitter — https://twitter.com/whatyouhide
Andrea Leopardi on GitHub — https://github.com/whatyouhide/corsica
Testing Elixir — http://testingelixir.com/
Testing Elixir — https://pragprog.com/titles/lmelixir/testing-elixir/
Testing Elixir — https://www.target.com/p/testing-elixir-by-andrea-leopardi-jeffrey-matthias-paperback/-/A-83072057#lnk=sametab
Testing Elixir on Twitter — https://twitter.com/testingelixir
Publish with The Pragmatic Bookshelf — https://pragprog.com/become-an-author/
Ecto.Adapters.SQL.Sandbox — https://hexdocs.pm/ecto_sql/Ecto.Adapters.SQL.Sandbox.html
Mox — https://hexdocs.pm/mox/Mox.html
Command Line Options — https://hexdocs.pm/mix/1.12/Mix.Tasks.Test.html#module-command-line-options
Mocks and Explicit Contracts — http://blog.plataformatec.com.br/2015/10/mocks-and-explicit-contracts/
bypass — https://github.com/PSPDFKit-labs/bypass
Test-Driven Development with Phoenix — https://www.tddphoenix.com/
Tracey Onim — https://www.linkedin.com/in/tracey-onim-420b3316a?originalSubdomain=ke
Podii — https://www.apollo.io/companies/Podii/5c1df0e8f651257261ddc16a?chart=count

Special Guests: Andrea Leopardi and Jeffrey Matthias.

Scaling and The Growth Curve with Francesco Cesarini

podcast@smartlogic.io (SmartLogic LLC) — Thu, 03 Jun 2021 06:00:00 -0400

Joining us for this episode of Elixir Wizards is the vastly experienced and well-traveled Francesco Cesarini! Francesco is the founder of Erlang Solutions and we are so lucky to have him here on the show to talk about his personal and professional journey, and take this great season of shows on the magic of the BEAM even further. Francesco takes us through his early interactions with computers and coding and the events that led to his decision to study computer science, before diving into his move to Sweden, and subsequently the UK, and how this all resulted in the founding of his company. Our guest touches on some helpful lessons he learned around marketing and branding, particularly related to the name of the company and we also discuss how the company grew in stages over the years. From there, the conversation turns to Francesco's work on conferences, and his commitment to this important feature of the community. We talk about the benefits of virtual conferences, what to look forward to, and the team that Francesco works with when organizing. To finish off this segment, our guest gives a few recommended resources and comments on Erlang syntax too! For today's mini-feature we welcome Jeffery Utter who works as a Senior Software Developer at Bleacher Report, so make sure to tune in to catch it all!

Key Points From This Episode:

Francesco's route into coding from an early age and first forays into studying computer science.
The first job that Francesco had out of college: an exciting internship at Ericsson.
How Francesco founded Erlang Solutions after leaving Sweden and moving to London.
The big growth steps that happened over the years as Erlang Solutions developed.
Francesco's evolving mindset during this growth period and his attitude towards scaling the company.
The current size of the company and the offices that are spread all over the world!
Virtual conferences, more connectivity, and the benefits of getting involved in the community.
The planning process for conferences and the size of the team that put them together.
The growth curve for Erlang Solutions over the years and the main drivers in the process.
Examples from the explanatory videos that Francesco produced to help people understand Erlang.
Francesco's feelings about Erlang syntax and the misconceptions about its difficulty.
Recommendations of helpful resources to aid the learning curve.
Getting involved with Erlang Solutions and connecting with Francesco and his team!
Jeffery Utter from Bleacher Report joins us to briefly talk about his journey with Elixir.
The time that Jeffery spent working at Communication Service for the Deaf prior to Bleacher Report.
Some updates on the growth and evolution of Bleacher Report and what they offer users.
How Elixir is used at Bleacher Report and its succession of Ruby at the company.
Jeffery's alternate career paths and qualifications in music and education!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Elixir Conference — http://smr.tl/conf-podcast
Francesco Cesarini on Twitter — https://twitter.com/FrancescoC
Joe Armstrong — https://codersatwork.com/joe-armstrong.html
Erlang Solutions — https://www.erlang-solutions.com/
Erlang Programming Language - Computerphile — https://www.youtube.com/watch?v=SOqQVoVai6s
Chalmers University of Technology — https://www.chalmers.se/en/Pages/default.aspx
Erlang & Elixir Developers | Careers at Erlang Solutions — https://www.erlang-solutions.com/careers/
Code BEAM V SF 2021 — https://codesync.global/conferences/code-beam-sf-2021/.
RabbitMQ Summit— https://rabbitmqsummit.com/
Languages, and about languages, on the BEAM — https://github.com/llaisdy/beam_languages
Lambda Days 2021 — https://www.lambdadays.org/lambdadays2021
Code Mesh — https://codesync.global/conferences/code-mesh-ldn
Erlang Master Classes University of Kent — https://www.cs.kent.ac.uk/ErlangMasterClasses/
Professor Simon Thompson — https://www.kent.ac.uk/computing/people/3164/thompson-simon
Designing for Scalability with Erlang/OTP — https://www.oreilly.com/library/view/designing-for-scalability/9781449361556/
Erlang Programming — https://www.oreilly.com/library/view/erlang-programming/9780596803940/
Jeffery Utter — https://www.linkedin.com/in/jeffutter
Bleacher Report — https://bleacherreport.com/
Communication Service for the Deaf — https://www.csd.org/
Gallaudet University — https://www.gallaudet.edu/

Bringing the Magic of Math into Programming with Chris Miller

podcast@smartlogic.io (SmartLogic LLC) — Thu, 27 May 2021 06:00:00 -0400

Today we have some extra BEAM magic for all of you! Joining us on the show is Chris Miller, who currently works as an Associate Software Engineer at Corvus Insurance. We get into a great conversation with Chris about his history with programming, his long-held interest in mathematics, and how he is trying to bring these two worlds closer together through his work. Chris weighs in with some very important expert perspectives on a range of subjects, from monads and monoids to Vim and Emacs, before we get into the different avenues of Chris' work. Along with an old college friend, Chris runs the informative YouTube Channel, Coding Cave, helps other coders through mentorship and tutoring, and is also multilingual, speaking Mandarin, Spanish, German, and English! We get some illumination on interesting and important concepts such as Turing completeness, programming language theory, and more, all delivered with an accessibility that belies the high level of the material. So for all this, plus our bonus mini-segment with Semsee employee, Sidney Leatherwood, at the end, be sure to listen in today!

Key Points From This Episode:

The story behind Chris' Twitter handle and his admiration for Leonhard Euler!
How Chris is bringing his love of math into his programming work.
A crash course on monads and monoids!
Chris' teaching and tutoring work and his aim of bringing fun examples into learning.
The YouTube channel that Chris runs with an old friend, called Coding Cave.
Chris' take on the Vim versus Emacs debate.
How Chris learned to program from his father, and his return to it during college.
Unpacking programming language theory and the idea of Turing completeness.
Chris clears up the difference between computer science and mathematics.
Reasons that Chris enjoys working in Elixir compared with other languages.
Chris' goals for his YouTube channel and his hopes to spread advanced education.
Magic and languages; a programming language theory perspective.
Chris' day job as a software engineer at Corvus Insurance using Elixir and Elm.
The array of languages that Chris can speak; Mandarin, German, and Spanish.
The process of language acquisition and Chris' methods for learning.
Why Chris believes starting with the function is the best way to learn a new programming language.
The aspects of Elixir and the BEAM that have Chris the most excited at the moment!
This week's mini-feature with Sidney Leatherwood and his use of Elixir in production.
The comparative rating service that Semsee offers their customers.
Hiring in Elixir currently; perks, challenges, and resources in the space.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Chris Miller on Twitter — https://twitter.com/blackeuler
Elixir Wizard Conference — http://smr.tl/conf-podcast
Leonhard Euler — https://en.wikipedia.org/wiki/Leonhard_Euler
Curry–Howard Correspondence — https://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspondence
Haskell — https://www.haskell.org/
Brooklyn Zelenka — https://medium.com/@expede
Coding Cave — https://www.youtube.com/channel/UCwIO8jv71cbOyEwJdrYov_g
Conversations with the Creator: José Valim — https://www.youtube.com/watch?v=BXpoKKkqAX4
Functor — https://en.wikipedia.org/wiki/Functor
Spacemacs: Emacs advanced Kit focused on Evil — https://www.spacemacs.org/
hlissner/doom-emacs — https://github.com/hlissner/doom-emacs
Turing Completeness — https://en.wikipedia.org/wiki/Turing_completeness
Cal Newport — https://www.calnewport.com/
Boolean Algebra — https://en.wikipedia.org/wiki/Boolean_algebra
Clojure — https://clojure.org/
Corvus Insurance — https://www.corvusinsurance.com/
APL — https://en.wikipedia.org/wiki/APL_(programming_language)
Gleam - https://gleam.run/
Sidney Leatherwood on LinkedIn — https://www.linkedin.com/in/leather-s
Semsee — https://semsee.com/

Special Guest: Chris Miller.

The Controlled Magic of Oban with Parker and Shannon Selbert

podcast@smartlogic.io (SmartLogic LLC) — Thu, 20 May 2021 06:00:00 -0400

While there is magic to be found in many frameworks, having too much going on under the hood without you being able to control it is not for everybody. Today we invite Parker and Shannon Selbert to speak about their dynamic partnership and the ‘controlled magic’ of their tool Oban. Together Parker and Shannon founded Soren, where they help clients with established web apps stabilize, scale, and ‘add schmancy features’. Their tool Oban is a persistent background job processor written in Elixir whose differentiating feature revolves around keeping jobs after they're processed. We dive right in with Parker and Shannon hearing about how they got into programming before they talk about Oban and what sets it apart. Next up we get into how our guests navigate their personal relationship and professional partnership and they weigh in on homeschooling kids, writing new features, and the necessary life skills for handling Oban user support. Moving onto the topic of the BEAM, we explore the unique type of magic it offers and how this plays into some of the cooler features of Oban such as being able to cancel jobs. Our guests talk about some of the kinks they still need to work out of their tool and we wrap up our conversation on the pro version of Oban and how successful it has been. As always we close today’s show off with our mini-interview, this time with Joe Peck from Spreedly!

Key Points From This Episode:

The illicit stories behind how Parker and Shannon got into tech.
Understanding Oban, a persistent background job processor written in Elixir.
How Oban is different from other job processors like Sidekiq.
The great partnership our guests have and the story behind Soren.
How Parker and Shannon differentiate their personal and professional life.
The approach Parker and Shannon take to handling Oban user support.
Perspectives on the magic of homeschooling, relationships, and Oban!
Different kinds of magic provided by different frameworks and why Elixir magic is the best.
How Parker and Shannon got interested in Erlang, BEAM, and Elixir.
The best part about maintaining an open-source project.
The story behind getting a global concurrency lock on handling batches.
Added features that come with upgrading to the pro version of Oban.
Canceling a job on Oban and the role the BEAM plays in allowing this.
Writing documentation for Oban and our guest’s plans to make video tutorials.
The shift in digital learning more towards video tutorials.
Perspectives on whether we have arrived at a golden age in computing yet.
Challenges around implementing seamless horizontal scaling in Oban.
Making a living and working on Oban; advantages of setting up a pro version.
Our mini-interview with Joe Peck where we explore his journey with Elixir.

Links Mentioned in Today’s Episode:

Elixir Wizards |> Conference — https://smr.tl/conf-podcast
SmartLogic — https://smartlogic.io/
Soren on Twitter — https://twitter.com/sorentwo?lang=en
Soren — https://sorentwo.com/
Parker Selbert on GitHub — https://github.com/sorentwo
Shannon Selbert on GitHub — https://github.com/sorenone
Oban — https://github.com/sorentwo/oban
Sidekiq — https://sidekiq.org/
Lawnmower Man — https://www.imdb.com/title/tt0104692/
Soren Kierkegaard — https://www.britannica.com/biography/Soren-Kierkegaard
Ender's Game — https://www.amazon.com/Enders-Ender-Quintet-Orson-Scott/dp/0812550706
Joe Peck — https://peckyeah.com/
Spreedly — https://www.spreedly.com/

Special Guests: Parker Selbert and Shannon Selbert.

The Right Amount of Magic with Erik Person

podcast@smartlogic.io (SmartLogic LLC) — Thu, 13 May 2021 06:00:00 -0400

Today we are joined by the Vice President of Engineering at Corvus Insurance, Erik Person! Erik continues our journey into the magic of the BEAM, our season-long theme for the Elixir Wizards Podcast, and we get to hear all about Erik's path in programming, his relationship with Elixir, and his utilization of the BEAM. Growing up in a family involved in computer science, and an early affinity for technology made the choice of what to study at college a straightforward one for Erik. He tells us about his life during and after those school years, touching on his first job and the important milestones leading up to his current position at Corvus. We talk about his early feelings for Elixir and why it appealed to him almost immediately before discussing different languages on the BEAM and his love of types! Our guest also shares some of the bigger challenges he has encountered working in Elixir and touches on the issue of scaling effectively. In this episode, we also air a mini-feature with SmartLogic's very own Stephanie Vizzi, talking about her work at the company, relationship with Elixir, and more! So for all this, plus a lot in between, be sure to tune in!

Key Points From This Episode:

Erik's family ties to computer science and his path leading into programming.
The first job that Erik landed in programming and his current role at Corvus Insurance.
The BEAM at Corvus and the general architecture of the company's technology.
Erik's first encounters and learnings with Elixir and the questions it answered for him immediately.
The learning curve for languages on The BEAM; Erik's own journey to understanding.
Erik's preference for types and his wish for their inclusion on Elixir!
Lisp on The BEAM; Erik unpacks his perspectives and the blog post he wrote on the subject.
Getting to grips with abstract forms and how these terms operate in Erlang and Elixir.
The challenges that Erik experienced parsing and manipulating the code in Elixir.
Erik weighs in on BEAM magic; appreciating the magic that is possible with Elixir and Elm.
Perspectives on scaling on Elm and Elixir as an application grows rapidly.
How Erik and his team typically use contexts and service-oriented architecture.
Challenges with compile times during the process of scaling of the application.
Excitement about the progressive steps in the data science component of Corvus.
How Erik applied his skills to his passion for playing blackjack by creating a card-counting application.
The remote meeting hardware device that Erik built as a pandemic side-project!
This week's community mini-feature! Looking at how Stephanie Vizzi got into and uses Elixir.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Erik Person on LinkedIn — https://www.linkedin.com/in/erik-person-a9368bb
VirtualBox — https://www.virtualbox.org/
Tunnelblick — https://tunnelblick.net/
Corvus Insurance — https://www.corvusinsurance.com/
Corvus Job Openings — https://boards.greenhouse.io/corvusinsurance/
Clojure — https://clojure.org/
Saša Jurić — https://github.com/sasa1977
LFE — https://lfe.io/
Elm — https://elm-lang.org/
Robert Virding — https://codesync.global/speaker/robert-virding/
The Erlang Rationale — https://elixirforum.com/t/the-erlang-rationale-by-robert-virding-pdf/35313
Paul Graham — http://www.paulgraham.com/
Hackers and Painters — https://www.amazon.com/Hackers-Painters-Big-Ideas-Computer/dp/1449389554
Myers Briggs — https://www.myersbriggs.org/my-mbti-personality-type/mbti-basics/
Chris McCord — http://chrismccord.com/
Mix Xref — https://hexdocs.pm/mix/Mix.Tasks.Xref.html
Gleam — https://gleam.run/
Leex — http://erlang.org/doc/man/leex.html
GNU Bison - The Yacc-compatible Parser Generator — https://www.gnu.org/software/bison/manual/
YACC — https://www.geeksforgeeks.org/introduction-to-yacc/
Stephanie Vizzi on LinkedIn — https://www.linkedin.com/in/stephanie-vizzi-b1158996

Special Guests: Erik Person and Stephanie Vizzi.

Robert Virding on the Roots of Erlang

podcast@smartlogic.io (SmartLogic LLC) — Thu, 06 May 2021 06:00:00 -0400

Welcome to a brand-spanking-new season of Elixir Wizards! This time around we will be focussing on the magic of the BEAM, so get ready for an exciting journey into new territories filled with mystery and power! To kick things off in this inaugural episode we are joined by a true legend in the space of Erlang, Elixir, and the BEAM. Robert Virding is one of the three founding members of Erlang, and his unrivaled intimacy with the language and its related subjects is truly inspiring and informative. We feel like we could fill many more episodes just hearing Robert unpack the history he has been involved in, but we do manage to cover a lot in this show, touching on Robert's career arcs, the other founders of Erlang, the connection to Ericsson and the bridge to Elixir, as well as much more. Robert also shares some insight into the BEAM and the idea of a virtual machine, broaching these sometimes misunderstood concepts with simplicity and clarity. We talk about magic, hurdles, best practices, and the future of community, with Robert sharing his experiences working on Erlog, LFE, and much more. Make sure to join us for this episode and stay tuned for the rest of another great season!

Key Points From This Episode:

Robert's description of the Erlang Rationale document and why it was important to create it.
Background information on the founding three members of Erlang and how they came together.
Training and early career as a computer scientist; Robert's background before Ericsson.
The roots of the Erlang name, and how Robert first came across and connected with it.
The simplest definition of the BEAM, Bogdan’s Erlang Abstract Machine!
Unpacking the application of a virtual machine and the connection between Erlang and BEAM.
Information on Core Erlang and how it works within the compiler.
LFE or Lisp-Flavored Erlang and the decisions that were made to keep it straightforward.
Hurdles to learning Erlang and Robert's thoughts on getting over these.
Weighing the usefulness of 'magic' and the caution with which Robert approaches it.
Best practices for Erlang and Elixir according to Robert; the biggest shifts necessary for success.
Robert's first feelings about the arrival of Elixir and the questions it raised for him.
The motivation behind Robert's work on Erlog!
Reflections on the Erlang movies that Ericsson produced and their evolution over time!
The future of Erlang, its community, and the need for continued and increased collaboration.
Why Robert wants to put more parentheses back in the mix!

Links Mentioned in Today’s Episode:

SmartLogic - https://smartlogic.io/
Robert Virding - https://codesync.global/speaker/robert-virding/
Robert Viriding on Twitter - https://twitter.com/rvirding?lang=en
The Erlang Rationale - https://elixirforum.com/t/the-erlang-rationale-by-robert-virding-pdf/35313
Prolog - https://www.swi-prolog.org/
Ericsson - https://www.ericsson.com/
Joe Armstrong - https://www.theguardian.com/education/2019/may/08/joe-armstrong-obituary
Mike Williams - https://codesync.global/speaker/mike-williams/
Fortran - https://fortran-lang.org/
Pascal - http://www.pascal-programming.info/index.php
VAX - https://www.computerhope.com/jargon/v/vax.htm
Franz Lisp - https://franz.com/products/allegro-common-lisp/acl_prolog.lhtml
Agner Krarup Erlang - https://mathshistory.st-andrews.ac.uk/Biographies/Erlang/
Bogumil Hausman - https://peoplepill.com/people/bogumil-hausman
LFE - https://lfe.io/
Erlang The Abstract Format - https://erlang.org/doc/apps/erts/absform.html
Core Erlang - https://blog.erlang.org/core-erlang-by-example/
Erlog - https://github.com/rvirding/erlog
Lua in Erlang - https://github.com/rvirding/luerl
Erlang: The Movie - https://elixirforum.com/t/erlang-the-movie/440
Monty Python - http://www.montypython.com/
Erlang Ecosystem Foundation - https://erlef.org/
A first look at the JIT - https://blog.erlang.org/a-first-look-at-the-jit/
Lisp Cycles - https://xkcd.com/297/
Creative Assembly - https://www.creative-assembly.com/home
Total War - https://www.totalwar.com/
World of Warcraft - https://worldofwarcraft.com/en-us/

Special Guest: Robert Virding.

Adopting Elixir Finale with Sean Lewis, Anna Neyzberg, and René Föhring

podcast@smartlogic.io (SmartLogic LLC) — Thu, 25 Mar 2021 06:00:00 -0400

Season 5 ends with a bang as we welcome back Sean Lewis, Anna Neyzber, and René Föhring onto the show to share their journey on getting their companies and teams to adopt Elixir. We open our conversation with each guest sharing their first experiences with Elixir. After chatting about the changes that they’ve seen in the Elixir ecosystem, we explore Elixir’s benefits and how they’ve persuaded companies to make the Elixir leap. From zero downtime deployment to arguing for Elixir’s ability to solve immediate problems, we touch on the most convincing reasons for stakeholders to adopt Elixir. Following this, we unpack common Elixir criticisms before looking at the importance of hiring developers for their aptitude as well as for their skill set. Later, we discuss what we most appreciate about Elixir, with each guest sharing a story from producing an Elixir app. We round off an insightful episode by talking about Elixir accessibility and the top ways to train entry-level programmers. Join us as we wrap up this season for a last deep-dive on adopting Elixir.

Key Points From This Episode:

We introduce today’s panel, featuring Sean Lewis, Anna Neyzberg, and René Föhring.
Hear how each guest discovered Elixir and what they’ve seen change in the ecosystem.
Exploring our guests' first Elixir projects.
The intersections between Elixir and cryptocurrency.
How to persuade company stakeholders to adopt Elixir.
Why choosing a language for scalability often isn’t as important as its immediate benefits.
Unpacking common criticisms of Elixir adoption.
How a culture of learning can push your company in the right direction.
Anecdotes on getting companies to adopt Elixir.
We touch on the benefits of using Elixir.
Each guest reflects on their experiences producing and maintaining Elixir apps.
How our guests are currently using Elixir.
Using Credo to train new Elixir developers.
Advice on making Elixir accessible to entry-level coders.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Elixir Wizards Discord — https://smr.tl/wizards-discord
Elixir Wizards Email — podcast@smartlogic.io
Elixir Wizards Conference — https://smartlogic.io/about/community/elixir-wizards-conference/
Anna Neyzberg on LinkedIn — https://www.linkedin.com/in/anna-neyzberg-93545316/
Anna Neyzberg on Twitter — https://twitter.com/ANeyzb
Sean Lewis on LinkedIn— https://www.linkedin.com/in/sean-lewis-40375077/
René Föhring on Twitter — https://twitter.com/rrrene
René Föhring — https://rrrene.org/
ElixirBridge — http://elixirbridge.org/
Carbon Five — https://www.carbonfive.com/
Genesis Block — https://genesisblock.com/
Genesis Block Jobs — https://genesisblock.com/jobs
Credo on GitHub — https://github.com/rrrene/credo/
ElixirConf 2018 — https://elixirconf.com/2018
Ethereumex — https://hex.pm/packages/ethereumex
Mana — https://github.com/mana-ethereum/mana
Robinhood — https://robinhood.com/us/en/
Slack — https://slack.com/
PagerDuty — https://www.pagerduty.com/
Alexandra Episode — https://smartlogic.io/podcast/elixir-wizards/s5e10-chakeres/
Turing — https://turing.io/
Weedmaps — https://weedmaps.com/
Nav Inc. — https://www.nav.com/
ElixirStatus — https://elixirstatus.com/
Divvy — https://getdivvy.com/
Matt Mills — https://github.com/photomattmills
Factorio — https://factorio.com/
Dyson Sphere Program — https://store.steampowered.com/app/1366540/Dyson_Sphere_Program/

Special Guests: Anna Neyzberg, René Föhring, and Sean Lewis.

Jenn Gamble on Data Science, Machine Learning, and Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 18 Mar 2021 06:00:00 -0400

The fields of data science and machine learning are moving ever faster. Jenn Gamble has her finger on the pulse and has become an industry expert with a wealth of experience to her name. As today’s guest, she dives into these rich and often complex topics, and she helps us boil them down into palatable nuggets of knowledge. We start off by asking Jenn about her current role at Very, and she tells us about the nature of her team and the things they’re able to achieve. She touches on what the language markups look like for a data science team, before moving onto her experiences in machine learning and data science. Delving deeper, Jenn tells us why it is not a necessity to have a master’s in data science, and why you can be well enough equipped in other senses to become proficient in the area. Later on, she reveals the differences between Elixir models and data science models. Following these detailed explanations, she furnishes listener’s minds with informative comments on relating the foundations of machine learning to IoT, using priori knowledge to add nuance to your machine learning, and how she envisions the future of data science. Join us today and be sure to get all this, and much more!

Key Points From This Episode:

Introducing today’s guest, Jenn Gamble.
Jenn tells us about Very, an IoT engineering firm.
Hear about the data science team at Very.
We learn more on what the language markup looks like for a data science team.
Jenn’s experience in learning machine learning and data science.
Hear her five-year plan while doing her masters.
We ask if it’s necessary to have a master’s degree to be well-equipped in data science.
The difference between an Elixir model and a data science model.
Jenn elaborates on weights and intuitive algorithms.
Dealing with N-dimensional matrices.
Relating the foundations of machine learning to IoT.
Ways to start building up an intuition around what the most fundamental abstractions are.
Using priori knowledge to add nuance to your machine learning.
How Jenn envisions the future of data science.
Hear about tensors and vectors.
Jenn tells us about her keynote experience at ElixirConf 2020.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Elixir Wizards Discord — https://smr.tl/wizards-discord
Elixir Wizards Email — podcast@smartlogic.io
Jenn Gamble on Twitter – https://twitter.com/jennpgamble
Jenn Gamble on LinkedIn – https://www.linkedin.com/in/jenn-gamble/
ElixirConf 2020 - Keynote - Jenn Gamble – https://www.youtube.com/watch?v=btIvtN9ws_I&ab_channel=ElixirConf
IoT – https://www.verypossible.com/careers
Very – https://jobs.lever.co/verypossible
MathWorks – https://www.mathworks.com/products/matlab.html
Cassie Kozykrov – https://kozyrkov.medium.com/
Linear regression – http://www.stat.yale.edu/Courses/1997-98/101/linreg.htm
Pythagorean theorem – https://www.mathplanet.com/education/pre-algebra/right-triangles-and-algebra/the-pythagorean-theorem
Quadratic equation – https://www.mathsisfun.com/algebra/quadratic-equation.html
A priori and a posteriori – https://iep.utm.edu/apriori/
Tensor – https://mathworld.wolfram.com/Tensor.html
Vector (mathematics and physics) – https://mathinsight.org/vector_introduction
Coursera – https://www.coursera.org/learn/ai-for-everyone

Special Guest: Jenn Gamble.

John Mertens on Adopting Elixir at Change.org

podcast@smartlogic.io (SmartLogic LLC) — Thu, 11 Mar 2021 06:00:00 -0500

Many organizations take an incremental approach when adopting Elixir, preferring to pick up its nuances by using it to work on non-essential projects. But not Change.org. Today we speak with Change.org Director of Engineering John Mertens about how his company adopted Elixir to create a business-critical app that handles over a billion emails per month. From building webpages on GeoCities to working as an IT intern at an Iowan prison, we open our conversation by exploring John’s coding background. After chatting about his first Elixir project, we dive into Change.org’s process in adopting Elixir. As John shares his insights into successfully integrating Elixir into your tech stack, he highlights the benefits provided by the language. Later, John discusses the advantages of event-driven architecture and how this structure makes it easier for teams to access and analyze data, while also making it easier to add product features. We wrap up this episode with John highlighting his user-centered approach to coding. Join us to hear John’s lessons on making the leap and adopting Elixir in large organizations.

Key Points From This Episode:

John shares details about his role at Change.org.
The story behind John and Change’s Elixir adoption.
Hear about John’s coding journey.
How John made an Elixir app based on spotting San Francisco tram carriages.
Insights into the massive project that Change built using Elixir.
Why Elixir is taking over Change’s back-end tech stack.
Using Elixir to build reliable event-based architecture.
Exploring event-driven architecture from the perspective of Change’s system.
John makes a compelling case for event-driven architecture.
How Change hires for Elixir roles.
Change’s process in training their staff to code in Elixir.
John talks about his user-centred approach to design.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Elixir Wizards Discord — https://smr.tl/wizards-discord
Elixir Wizards Email — podcast@smartlogic.io
John Mertens — https://www.mertonium.com/about
John Mertens on Twitter — https://twitter.com/mertonium
John Mertens on GitHub — https://github.com/mertonium
Change.org — https://www.change.org/
Change.org Careers — https://careers.change.org/
José Valim — https://twitter.com/josevalim
GenStage and Flow - José Valim (Lambda Days 2017) — https://www.youtube.com/watch?v=XPlXNUXmcgE
Dashbit — https://dashbit.co/
Hacker News — https://thehackernews.com/
Paul Graham — https://twitter.com/paulg/
Nim — https://nim-lang.org/
Pony — https://www.ponylang.io/
Grax.io — https://www.grax.com/
Logo — https://el.media.mit.edu/logo-foundation/what_is_logo/logo_programming.html
Nerves — https://www.nerves-project.org/
Flow — https://hexdocs.pm/flow/Flow.html
ElixirConf EU — https://www.elixirconf.eu/
Martin Fowler — https://martinfowler.com/
‘The Log: What every software engineer should know about real-time data's unifying abstraction’ — https://engineering.linkedin.com/distributed-systems/log-what-every-software-engineer-should-know-about-real-time-datas-unifying
Salesforce Marketing Cloud — https://www.salesforce.com/eu/products/marketing-cloud/overview/
‘Delivering social change with Elixir at Change.org’ — https://elixir-lang.org/blog/2020/10/27/delivering-social-change-with-elixir-at-change.org/
Code for America — https://www.codeforamerica.org/

Special Guest: John Mertens.

Sophie DeBenedetto on Programming Phoenix LiveView

podcast@smartlogic.io (SmartLogic LLC) — Thu, 04 Mar 2021 06:00:00 -0500

As users increasingly demand interactivity from their web experiences, Phoenix LiveView is becoming the dominant way of writing interactive Elixir applications without a loss to reliability. Today we welcome back an old friend of the show and GitHub engineer Sophie DeBenedetto to talk about her upcoming book, Programming Phoenix LiveView. We open our conversation with Sophie by hearing about her work at GitHub, as well as what we can expect from the Code BEAM V conference. As she doesn’t always get to use Elixir at her job, Sophie then discusses how coders can sharpen their Elixir skills when not at work. After exploring how companies can begin adopting Elixir through event-driven design, we dive into Sophie’s book. She unpacks the value of LiveView when building efficient web applications before touching on how her book can best help people to learn LiveView. We ask Sophie how intertwined the future of Elixir is to the success of LiveView and how this might impact Phoenix. Her answers highlight LiveView’s role in pushing Elixir adoption while also making Elixir easier to learn. We wrap up our discussion by chatting about the challenges of technical writing and Sophie’s experience working with the wonderful Pragmatic Programmers publishing house. Tune in to hear more insights into programming LiveView; if you believe the hype, it’s “one of the most important new frameworks of our generation.”

Key Points From This Episode:

We catch up with guest Sophie DeBenedetto and hear about the Code BEAM V conference.
Sophie shares her feelings on coding in Go.
How Sophie engages with Elixir when it’s not a key part of her day job.
What Flatiron School did to work towards Elixir adoption.
Exploring the concept of event-driven design.
Insights into the eventing system used at GitHub.
Sophie talks about her experience as an engineering manager.
Why Sophie transitioned from being a manager to being an individual contributor.
How work-from-home has impacted meeting expectations.
Hear the elevator pitch for Sophie’s upcoming book.
Thoughts on how beginner-friendly Elixir is as a language.
Whether Phoenix LiveView is the future of Elixir.
How the attention placed on LiveView limits access to Phoenix resources and tutorials.
We ask Sophie if LiveView will make it easier or more difficult to learn Elixir.
Advice on writing technical books and the writing support offered by Pragmatic Programmers.

Links Mentioned in Today’s Episode:

Special Guest: Sophie DeBenedetto.

Shaun Robinson and Toran Billups on Using Elixir to Empower Online Learning

podcast@smartlogic.io (SmartLogic LLC) — Thu, 25 Feb 2021 06:00:00 -0500

With the prevalence of at-home learning, teachers have to compete for student attention against numerous screen-based activities. Today we speak with engineering lead Shaun Robinson and Elixir developer Toran Billups about how Legends of Learning helps educators make their classrooms fun, engaging, and productive through their curriculum-based games. After chatting about Legends’ mission to empower teachers, we talk with Toran about how he landed a job there. He then shares his insights into securing Elixir jobs, touching on the importance of networking and building a portfolio of Elixir projects. We discuss why Elixir became Legends’ language of choice before exploring their process in adopting Elixir. Reflecting on their early server structure, Shaun explains their process of refactoring from their old code base into an Elixir monolith. Responding to a previous episode, where frustrations were shared about coding in LiveView, Toran talks about its advantages, despite its issues as a new technology. Later, Shaun and Toran dive into what you can do to help your company adopt Elixir. We wrap up another incredible conversation by asking our guests about their favorite Legend of Learning games. Tune in to hear more about Legend of Learning’s Elixir journey and how they’re using it to create dynamic learning environments.

Key Points From This Episode:

Exploring the mission and work of the Legends of Learning startup.
Shaun and Toran share details about their backgrounds.
Why building a van home is so similar to building software.
Hear about Toran’s podcast on the human side of programming.
Shaun talks about the time when he sold his Twitter and GitHub handle.
What Toran did to land his first Elixir job.
Why Legends of Learning decided to adopt Elixir.
Insights into Legends of Learning’s early server architecture.
Toran unpacks Legend’s hiring process.
Why Shaun’s engineering team consists of remote workers.
Toran shares the virtues of coding in LiveView.
What Shaun did to refactor their old code base into an Elixir monolith.
The process that Legends underwent when adopting Elixir.
Advice on finding an Elixir role and adopting Elixir in your company.
Hear about Shaun and Toran’s favorite Legend of Learning games.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Elixir Wizards Email — podcast@smartlogic.io
Shaun Robinson on LinkedIn — https://www.linkedin.com/in/shaun1010/
Toran Billups on Twitter — https://twitter.com/toranb
Toran Billups on LinkedIn — https://www.linkedin.com/in/toranb/
Legends of Learning — https://www.legendsoflearning.com/
Vadim Polikov — https://www.linkedin.com/in/vadim-polikov/
Developing Fatigue Podcast — https://developingfatigue.fm/
Kris Van Houghton — https://twitter.com/krivaten
Dave Gardner — https://www.linkedin.com/in/davegardner01/
Legends of Learning Careers — https://www.legendsoflearning.com/interested-game-developer/
Legends of Learning API Docs — https://docs.legendsoflearning.com/
Lonestar Elixir — https://lonestarelixir.com/
Elixir Match —https://elixirmatch.com/
Elixir Match on GitHub — https://github.com/toranb/elixir-match
Chris McCord — http://chrismccord.com/
Grox.io — https://grox.io/
Bruce Tate — https://www.linkedin.com/in/bruce-tate-a836b/
Postgraphile on GitHub — https://github.com/graphile/postgraphile
Martin Fowler — https://martinfowler.com/
The Strangler Application — https://martinfowler.com/bliki/StranglerFigApplication.html
Timescale — https://www.timescale.com/
‘TimescaleDB 2.0 is now Generally Available’ — https://blog.timescale.com/blog/timescaledb-2-0-is-now-generally-available/
Sun, Moon & Stars: Patterns of Apparent Motion on Legends of Learning — https://www.legendsoflearning.com/learning-objectives/the-sun-moon-and-stars-patterns-of-apparent-motion/
Magic the Gathering — https://magic.wizards.com/en
Legends of Learning Awakening — https://www.legendsoflearning.com/blog/homework-and-test-prep-math-and-science-game/
Hour of Code — https://hourofcode.com/
Owl Pro — https://owllabs.com/products/meeting-owl-pro

Correction: In an earlier version of this episode, the host mis-spoke and mis-named the guests' company name in the outro; that error has been corrected as of 2021-02-25 3:52PM ET.

Special Guests: Shaun Robinson and Toran Billups.

Brian Howenstein on How ClusterTruck is Innovating Food Delivery

podcast@smartlogic.io (SmartLogic LLC) — Thu, 18 Feb 2021 06:00:00 -0500

ClusterTruck, a master of vertical integration, is rewriting the method of end-to-end food delivery and ghost kitchens. Today we speak with ClusterTruck Product VP Brian Howenstein to find out more about his journey in programming, ClusterTruck as an end-to-end food service, and how Elixir became mission-critical to the success of the business.

We kick things off by hearing more on Brian’s childhood and how he became interested in programming. We then hear about his internship at Apple where he was part of the Core OS networking team. Brian touches on brushing shoulders with Steve Jobs, Jony Ivy, and Tim Cook, and shares how these personalities changed his view of the tech industry. Later in the show, we turn our attention to current times. Brian expands on his role at ClusterTruck and shares details on how Elixir has played a vital role in the company’s success. We hear his take on vertical integration, why they’d never consider third-party delivery companies, and much more. We then briefly digress to Brian’s hobby: the Scottish Games, before returning to ClusterTruck to find out what his favorite menu items are and what the future holds for food delivery and ghost kitchens.

Be sure to stay tuned to enjoy our mini-feature where we speak with Michelle Morry, a software engineer at FuturePet. For all things Elixir, be sure to join us today!

Bonus: If you’re in Indianapolis, IN, Columbus, OH, or Kansas City, MO, download the ClusterTruck app and use code “ELIXIRWIZARDS” at checkout for a one-time 25% discount on your ClusterTruck order. Good for a single use for both new and returning customers.

Key Points From This Episode:

A call to all talented engineering managers to join our team!
Introducing today’s guest, Brian Howenstein.
Brian tells us about his company, ClusterTruck.
Hear about Brian’s background in technology and programming.
What inspired Brian to do programming professionally.
Brian tells us about his internship at Apple.
Hear one of Brian’s fondest anecdotes about Jony Ive.
Brian shares notes on his path to Elixir.
Why Elixir has had such an impact on ClusterTruck’s success.
ClusterTruck’s origin story.
Brian talks about ClusterTruck’s vertical integration model.
How Brian got the people around him to buy into Elixir and the hurdles that came with it.
Brian talks about his journey to become a ClusterTruck VP.
Brian tells us about his hobby and we digress to World’s Strongest Man controversy.
How COVID has affected Brian’s business.
Nerves projects at ClusterTruck and how it’s being used.
What the future looks like for ClusterTruck.
Brian’s advice for people who are trying to get their company to code in Elixir.
How ClusterTruck is using LiveView.
Brian’s favorite and least favorite menu items.
Stay tuned for our quick mini-feature.

Links Mentioned in Today’s Episode:

ClusterTruck — https://www.clustertruck.com/
ClusterTruck Hiring — https://www.notion.so/clustertruck/Engineering-Openings-at-ClusterTruck-ef2372d2c2ab43b3b82f56a097c86eeb
Cabermetrics — https://www.cabermetrics.com/
Brain Howenstein on LinkedIn — https://www.linkedin.com/in/brianhowenstein/
Brain Howenstein on Twitter — https://twitter.com/hwrd
Indianapolis Scottish Games Festival — https://indyscotgamesandfest.com/
Purdue University — https://www.purdue.edu/
SimCity — https://www.ea.com/en-gb/games/simcity
Apple — https://www.apple.com/
Jony Ive — https://www.britannica.com/biography/Jonathan-Ive
Tim Cook — https://twitter.com/tim_cook
Steve Jobs — https://www.biography.com/business-figure/steve-jobs
Uber Eats — https://www.ubereats.com/za
ExactTarget — https://www.linkedin.com/company/exacttarget/
Salesforce — https://www.salesforce.com/
DoorDash — https://www.doordash.com/en-US
GrubHub — https://www.grubhub.com/
The World’s Strongest Man — http://theworldsstrongestman.com/
Raspberry Pi — https://www.raspberrypi.org/
Indy Elixir - Using Elixir at ClusterTruck: Milliseconds Matter When Your Users are Hangry — https://www.youtube.com/watch?v=9LMzYTK6dsE&ab_channel=IndyElixir
Indy Elixir - /hungry until food arrives: How ClusterTruck uses Elixir to make ordering for a Team Simple — https://www.youtube.com/watch?v=ZY2XeIENMRw&ab_channel=IndyElixir
ClusterTruck: Liberate Your Appetite — https://www.youtube.com/watch?v=xNC3vrrxNWM&ab_channel=ClusterTruck
Sean in the City: ClusterTruck Indy — https://www.youtube.com/watch?v=-nusA13LYJI&ab_channel=B105.7Indy
ClusterTruck + Slack — https://www.youtube.com/watch?v=C6t8aZQPB68&ab_channel=ClusterTruck

Special Guest: Brian Howenstein.

Yair Flicker on SmartLogic’s Origin, Evolution, and Elixir Adoption Process

podcast@smartlogic.io (SmartLogic LLC) — Thu, 11 Feb 2021 06:00:00 -0500

Building a successful development company requires having a leader with technical know-how and excellent management skills. Today we speak with SmartLogic President and Founder Yair Flicker about his company’s origin story, evolution, and their Elixir adoption process. Early in the episode, we talk about Yair’s first jobs before diving into how he founded SmartLogic. An important transition point, we then chat about how he moved from writing code to running a business. Reflecting on his tech background, Yair opens up about how he learned to code before he shares insights into the languages that his company programs in, how they discovered Elixir, and how they integrated it into their practice. In a discussion that’s sure to resonate with startup managers, Yair unpacks what he does to grow as a manager, along with best practices for companies looking to adopt Elixir. We ask Yair about the benefits of coding in Elixir, how SmartLogic has retained its top employees, why he prioritizes employee happiness, and the role that company values play in strengthening SmartLogic. After hearing about Yair’s vision for the future, we jump into our mini-segment where we interview Jake Johnson, the Director of Software Engineering at TaxJar. For more on building strong companies and advice on adopting Elixir, be sure to tune in and benefit from our conversations with Yair and Jake.

Key Points From This Episode:

SmartLogic Founder Yair Flicker talks about his first job.
Yair shares details about SmartLogic’s humble origins.
Early challenges SmarLogic faced and Yair’s move from coding to running a business.
We ask Yair about how he learned to code.
SmartLogic’s coding evolution and how they discovered Elixir.
The Maker vs. Manager distinction; what Yair did to grow as a manager.
Exploring the benefits of adopting Elixir.
Yair’s advice for companies wanting to adopt Elixir.
Why Elixir allows for more scalability than many other languages.
How SmartLogic has been able to retain some of its top employees.
The link between having happy employees and happy clients.
How Yair lives his company’s values.
Yair shares his recipe for creating productive meetings.
Hear about Yair’s vision for SmartLogic’s future.
For our mini-feature segment, we chat with Jake Johnson from TaxJar.
Why TaxJar adopted Elixir and details on Jake’s background.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Elixir Wizards Email — podcast@smartlogic.io
Yair Flicker on LinkedIn — https://www.linkedin.com/in/yflicker/
Yair Flicker on Twitter — https://twitter.com/yflicker
Jake Johnson on LinkedIn — https://www.linkedin.com/in/jakej/
TaxJar — https://www.taxjar.com/
Music and Arts — https://www.musicarts.com/
Johns Hopkins University — https://www.jhu.edu/
Hackers — https://www.imdb.com/title/tt0113243/
National Conference of Synagogue Youth — https://ncsy.org/
Stanley Black & Decker — https://www.stanleyblackanddecker.com/
Reddit — https://reddit.com/
Discord — https://discord.com/
Instagram — https://www.instagram.com
Amazon Web Services — https://aws.amazon.com/
Sales Tax for Developers — https://salestax.dev
Backstreet Boys — https://linktr.ee/backstreetboys

Special Guest: Yair Flicker.

Alexandra Chakeres on Moving Towards an Inclusive Elixir Community

podcast@smartlogic.io (SmartLogic LLC) — Thu, 04 Feb 2021 06:00:00 -0500

Despite its welcoming character, the Elixir community struggles with diversity; as the 2020 ElixirConf community survey shows, only 2% of Elixirists are women. Today we speak with Blinker software engineer Alexandra Chakeres about her experience of the community, as well as what we can do to make it more inclusive. We open by exploring Alexandra’s background and coding career. After expressing her enthusiasm for the Turing School, we talk about Alexandra’s learn-by-doing approach to picking up Elixir. She shares how she landed her first Elixir job before we chat about her current role at Blinker. We discuss why the small size of the community means that Alexandra doesn’t recommend Elixir to coding beginners. We then dive into the topic of Elixir diversity, touching on factors that limit inclusivity, including how few Elixir positions are available for juniors. Alexandra unpacks solutions, like how organizations can shift their hiring pipeline and the need to approach diversity organizations with openings. Later, listeners will enjoy our mini-feature segment where we interview Instinct Science engineer Bill Peregoy about how their team uses Elixir. Tune in for more on what we can do to create a more diverse community.

Key Points From This Episode:

Hear how co-host Sundi Myint first met Alexandra.
Alexandra shares details about her coding background.
Why Alexandra feels so passionately about Turing Boot Camp.
Details about Alexandra’s first Elixir job.
What Alexandra’s current team builds in Elixir and her experience using umbrella apps.
Comparing Ruby with Elixir and insights into what Elixir is missing.
Why Alexandra doesn’t recommend that junior engineers first learn Elixir.
How restricted Elixir hirings lead to a lack of diversity in the community.
Exploring ways to make the Elixir community more diverse.
What Alexandra most enjoys about coding in Elixir.
Alexandra’s top advice for minorities in the Elixir community.
Why it’s up to all of us to create a more inclusive community.
We talk to Bill Peregoy about how the team at Instinct Science uses Elixir.
Bill’s challenges and benefits to writing in Elixir.
How Bill would help new hires learn Elixir.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Elixir Wizards Email — podcast@smartlogic.io
Alexandra Chakeres on LinkedIn — https://www.linkedin.com/in/alexandrachakeres/
Alexandra Chakeres on GitHub — https://github.com/chakeresa
Blinker — https://www.blinker.com/
ElixirConf — https://elixirconf.com
Brian Cardarella — https://twitter.com/bcardarella
Turing School — https://turing.io/
Angelfire — https://www.angelfire.lycos.com/
Melvin Cedeno — https://twitter.com/thecraftedgem
Weedmaps — https://weedmaps.com/
Denver Erlang and Elixir Meetup — https://www.meetup.com/Denver-Erlang-Elixir/
DC |> Elixir Meetup — https://www.meetup.com/DC-Elixir/
DispatchHealth — https://www.dispatchhealth.com/
Autotrader — https://www.autotrader.com/
José Valim - https://github.com/josevalim
Diversified Tech — https://www.diversifytech.co/
Women Who Code D.C — https://www.womenwhocode.com/dc
Bruce Tate — https://twitter.com/redrapids
Bill Peregoy on LinkedIn — https://www.linkedin.com/in/billperegoy/
Instinct Science — https://www.instinct.vet/
AppSense — https://www.ivanti.com/company/history/appsense

Special Guest: Alexandra Chakeres.

Matt Nowack and Jake Heinz on Elixir and Discord; Bonus: Arthi Radhakrishnan, Community.com

podcast@smartlogic.io (SmartLogic LLC) — Thu, 21 Jan 2021 06:00:00 -0500

In this episode we continue our conversation about adopting Elixir, this time with Matt Nowack and Jake Heinz from Discord, hearing them get into the features of Elixir that make it a great fit for building a real-time chat infrastructure system! We also invite Arthi Radhakrishnan from community.com for our mini-interview in the last chunk of the episode. Our chat begins with Jake and Matt telling Elixir developers exactly why they should not use Mnesia. They subsequently dive into their journeys in programming and the process of learning Elixir after joining Discord. They share a few aha-moments as well as challenging projects that asked them to get their heads around some of the more powerful features of Elixir, highlighting a way they used immutability for a project that asked them to efficiently calculate deltas for large member list updates. From there we get into the culture around onboarding new devs at Discord, the company’s popular open-source Elixir contributions, and some brags about the high performance of features of Discord built in Elixir. Wrapping up with Jake and Matt, we hear their suggestions for teams and devs hoping to adopt Elixir, where they strongly advise on learning OTP as well as Elixir’s standard library. After that, it’s time for our chat with Arthi, where we hear about her programming journey, how Elixir is being put to use at Community.com, how the company supports new devs learning Elixir, and more!

Key Points From This Episode:

Our guests’ thoughts on why Elixir developers shouldn’t use the database driver Mnesia.
How Jake and Matt got into programming and learned Elixir after joining Discord.
The history of the use of Elixir at Discord and some of the projects Jake helped build since.
The nuts and bolts of OTP; Jake’s experiences learning it along with Elixir at Discord.
Different projects Matt worked on after joining Discord and how they helped him learn Elixir.
Aha moments of learning Elixir; features of the language that acted as force multipliers in the development of different Discord projects.
Processes at Discord for helping new developers learn Elixir.
Open-source contributions from Discord to the Elixir community and the culture around this at Discord.
Issues around logging and memory allocation in Elixir and what our guests think could change.
The sheer power Elixir brought to the Discord project allowing rapid scale with a small team.
Jake weighs in on the strengths of Python, Rust and Elixir, as well as BEAM processes versus Goroutines.
Discord as a native Electron app and whether we will see it written in Rust.
Advice regarding adopting Elixir about the power of OTP and the standard library.
Introducing Arthi Radhakrishnan for our mini-interview at the end of the show.
Previous languages Arthi worked in and how she learned Elixir after joining community.com.
The fan chat service offered at community.com and some famous users.
Features of the community.com architecture built in Elixir.
The size of the team, the culture of hiring Elixir devs, and Arthi’s onboarding process at Community.com.
Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Matt Nowack on GitHub — https://github.com/ihumanable
Mat Nowack on Twitter — https://twitter.com/ihumanable?lang=en
Jake Heinz on GitHub — https://github.com/jhgg
Apply for a Position at Discord — https://discord.com/jobs
Stanislav Vishnevskiy on LinkedIn — https://www.linkedin.com/in/svishnevskiy/
ZenMonitor — https://github.com/discord/zen_monitor
SortedSet Nif — https://github.com/discord/sorted_set_nif
The BEAM Book — https://github.com/happi/theBeamBook
Semaphore — https://github.com/discord/semaphore
ExHashRing — https://github.com/discord/ex_hash_ring
erts_alloc Documentation — https://erlang.org/doc/man/erts_alloc.html
Arthi Radhakrishnan on LinkedIn — https://www.linkedin.com/in/arthiradhakrishnan/
Community.com
Andrea Leopardi on LinkedIn — https://www.linkedin.com/in/anleopardi/?originalSubdomain=it

Special Guests: Jake Heinz and Matt Nowack.

Jason Axelson on the Elixir Language Server

podcast@smartlogic.io (SmartLogic LLC) — Thu, 14 Jan 2021 06:00:00 -0500

Welcome back to the Elixir Wizards podcast! In this episode, we will be continuing our conversation on the theme of adopting elixir, and our great guest for today is Jason Axelson! Jason is a back-end developer for a mixed reality studio called Animal Repair Shop and has also made some significant contributions to the Elixir Language Server project. We kick off our conversation with Jason hearing about his programming journey and then dive into the event chat service app he helped build using Elixir while he was working at Hobnob. From there, we talk about some of his aha moments while learning Elixir and some of his favorite features about the language which he is putting to use building out the back end for Animal Repair Shop. Next, we turn our attention to Elixir Language Server and Jason weighs in on the IDE type features it offers, why he got started as a collaborator on the project, and some of their challenges in the field of shared governance. Wrapping up for today, Jason makes a few suggestions for how devs who love Elixir can convince their teams to adopt it as a more mainstream option. Tune in for a great chat on the topic of adopting Elixir!

Key Points From This Episode:

An introduction to Jason Axelson and the story of how he got into programming.
Some of the books our hosts and guests read as kids and how they relate to programming.
How Jason got into Elixir while working on a chat service for events app at Hobnob.
Jason’s current project using Elixir to build the back end for Animal Repair Shop.
What caused Hobnob to switch to Elixir for their chat app and Jason’s aha moments learning it.
The TLDR version of the project that birthed ‘Road to 2 Million WebSocket Connections’.
What Jason loves about Elixir — pattern matching, immutability, explicitness.
Why Jason and his team at Animal Repair Shop are building their back end in Elixir.
The features provided by the Elixir Language Server for giving IDEs Elixir type support.
Jason’s involvement with GitHub/ElixirLSP; why he got involved, the project’s architecture, etc.
Some of the most challenging aspects of working on ElixirLS for Jason.
Jason’s talk on ElixirLS at ElixirConf – its content, doing it virtually, and more.
New features in the pipeline for ElixirLS; formatting speed improvements and more.
The role that good tooling plays in being able to learn a language more easily.
What needs to happen for Elixir to become a more mainstream back end option.
Advice from Jason regarding ways to convince your firm to adopt Elixir.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Jason Axelson on LinkedIn — https://www.linkedin.com/in/jasonaxelson
Jason Axelson on GitHub — https://github.com/axelson
Jason Axelson on Twitter — https://twitter.com/bostonvaulter?lang=en
Priv_check by Jason Axelson — https://github.com/axelson/priv_check
Jason Axelson ElixirConf ElixirLS Talk — https://2020.elixirconf.com/speakers/126/talk
A Definitive Guide to JavaScript — https://www.oreilly.com/library/view/javascript-the-definitive/9781491952016/
Hobnob — https://hobnob.app/
Elixir for Programmers by Dave Thomas — https://codestool.coding-gnome.com/courses/elixir-for-programmers
Animal Repair Shop — https://www.animalrepairshop.com/about/
‘Road to 2 Million WebSocket Connections’ — https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections
Elixir Getting Started Guide — https://elixir-lang.org/getting-started/introduction.html
GitHub/ElixirLP — https://github.com/elixir-lsp/elixir-ls
Adopting Elixir — https://pragprog.com/titles/tvmelixir/adopting-elixir/
Elixir Slack — https://elixir-slackin.herokuapp.com/
elixir-lsp/elixir-ls: Issue #274 — https://github.com/elixir-lsp/elixir-ls/issues/274
elixir-lsp/elixir-ls: Issue #381 — https://github.com/elixir-lsp/elixir-ls/issues/381

Special Guest: Jason Axelson.

Steve Domin on Innovating Travel APIs

podcast@smartlogic.io (SmartLogic LLC) — Fri, 08 Jan 2021 06:00:00 -0500

Anyone who has written software for the travel industry can tell you that it is in desperate need of innovation — shockingly many of their cobwebbed systems were built in the 70s. Today we speak with Duffel CEO Steve Domin, who is building tech that can finally align travel with the expectations of modern consumers. We open by exploring Steve’s journey into coding before diving into how Duffel is innovating travel. After touching on how the pandemic has impacted Duffel’s roll-out, Steve shares horror stories about the outdated tech and API systems that airlines use. We discuss Duffel’s service offerings and why Elixir is uniquely suited to solve the problems that Steve’s company is addressing. Steve then talks about the types of engineers that Duffel hires, his client base, and where his company is heading. Near the end of the episode, we ask Steve for his advice on selling your company on Elixir and we chat about the status of the London Elixir Meetup. Tune in for more insights on how Steve is using Elixir to make travel an effortless experience.

Key Points From This Episode:

Introducing Duffel CEO Steve Domin.
Steve shares details about his coding journey and career highlights.
Insights into the old school ecosystem of Flash, Flex, and ActionScript.
Exploring how Duffel is innovating the travel industry.
Why Duffel accelerated their roll-out due to the pandemic.
Steve unpacks the outdated tech and API systems that airlines use.
Why Duffel decided to use Elixir to tackle their problems.
The benefits of using Elixir when dealing with airline data.
Steve gives listeners an overview of Duffel’s pipeline.
Insights into the types of engineers that Duffel hires.
Who Duffel’s clients are and how they’re onboarded.
Steve reflects on some airline API horror stories.
Hear about Duffel’s roadmap — the future is bright.
What Elixir has uniquely enabled Duffel to do.
Steve’s advice on selling Elixir to stakeholders in your company.
The status of the London Elixir Meetup.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Steve Domin — https://stevedomin.com/about
Steve Domin on LinkedIn — https://www.linkedin.com/in/stevedomin/
Steve Domin on Twitter — https://twitter.com/stevedomin
Duffel — https://duffel.com/
Duffel Careers — https://duffel.com/careers
José Valim — https://twitter.com/josevalim
Flex — https://www.adobe.com/products/flex.html
Passenger Service System — https://en.wikipedia.org/wiki/Passenger_service_system
Global Distribution System — https://en.wikipedia.org/wiki/Global_distribution_system
Sabre — https://www.sabre.com/
Amadeus — https://amadeus.com/en
‘Why does NDC matter to my travel business?’ — https://duffel.com/blog/why-does-ndc-matter-to-my-travel-business
IATA — https://www.iata.org/
Next.js — https://nextjs.org/
GoCardless — https://gocardless.com/
Twilio — https://www.twilio.com/
Stripe — https://stripe.com/
Thomas Bates — https://www.linkedin.com/in/thomas-bates-3908a74b/
Elixir London Meetup — https://www.meetup.com/Elixir-London/
Baris Balic — https://twitter.com/barisbalic

Special Guest: Steve Domin.

Shawn Vo on Elixir as a Competitive Advantage

podcast@smartlogic.io (SmartLogic LLC) — Tue, 29 Dec 2020 06:00:00 -0500

To beat out their competitors, startups need to code quickly, simply, and in a language that attracts top engineers. Enter Elixir. Today we speak with Shawn Vo, Axle Payments Co-Founder and CTO, about his journey with Elixir and how it has given his company a competitive advantage. We open our conversation by exploring how Shawn got into coding while automating his work as an investment banker. After touching on why he sees programming as a superpower for adding value, he shares his growth hacks for learning a language — these range from reading old books to attending coding meetups. We then dive into Axle Payments’ business model, with Shawn highlighting the business opportunity of creating tech for industries that “people don’t think about.” A key theme in this episode, Shawn talks about how building in Elixir has helped Axle Payments hire the best engineers. We also discuss how Elixir allows them to quickly and efficiently write code that doesn’t break. Near the end of the episode, we explore Shawn’s browser extension projects and why he has a readme file to help guide people who want to work with him. Be sure to tune in to hear more insight from Shawn on the benefits of using Elixir in the startup space.

Key Points From This Episode:

Introducing Axle Payments CTO Shawn Vo.
From investment banking to coding, hear how Shawn got into our industry.
Why coding and creating content are top ways of creating value.
Reading books and getting into the fundamentals; tips on how Shawn learns a language.
Shawn shares details about his professional career.
How Shawn grew his skills by attending coding meetups.
Hear about Axle Payments’ model providing a factoring service.
How Shawn discovered and fell in love with Elixir.
Why Elixir has given Axle Payments their competitive advantage.
Shawn reflects on his first Elixir project.
The benefits of using event sourcing to build your app.
Why Shawn created a readme to guide people who want to work with him.
Shawn summarizes why Elixir is the perfect language for his company.

Links Mentioned in Today’s Episode:

Shawn Vo on LinkedIn — https://www.linkedin.com/in/shawnvo/
Shawn Vo on Twitter — https://twitter.com/shawnvo
Shawn Vo on GitHub — https://github.com/voshawn
Shawn Vo Email — shawn@axlepayments.com
Axle Payments — https://www.axlepayments.com/
The Technical Cofounder Newsletter — https://technicalcofounder.substack.com/
Meryl Dakin — https://twitter.com/meryldakin
WALL-E — https://www.imdb.com/title/tt0910970/
Barclays Investment Bank — https://www.investmentbank.barclays.com/
The Climate Corporation — https://www.climate.com/
The Monsanto Company — https://www.cropscience.bayer.com/
Federal Deposit Insurance Corporation — https://www.fdic.gov/
Deep Learning NYC — https://www.meetup.com/Deep-Learning-NYC/
Baltimore AI Meetup — https://www.meetup.com/Baltimore-AI/
Fast.ai — https://www.fast.ai/
Megabus — https://www.megabus.com/
Greyhound — https://www.greyhound.com/
Techstars — https://www.techstars.com/
Peter Thiel — https://www.forbes.com/profile/peter-thiel/
WeWork — https://www.wework.com/
Paul Graham — http://www.paulgraham.com/
Y Combinator — https://www.ycombinator.com/
‘The Python Paradox’ — http://www.paulgraham.com/pypar.html
Heroku — https://www.heroku.com/
Sessionizer — https://sessionize-me.herokuapp.com/
Hamilton — https://hamiltonmusical.com/new-york/home/
Slack — https://slack.com/
Phoenix — https://hexdocs.pm/phoenix/overview.html
Commanded — https://hexdocs.pm/commanded/Commanded.html
The Social Dilemma — https://www.imdb.com/title/tt11464826/

Special Guest: Shawn Vo.

Viktória Fördős on Erlang

podcast@smartlogic.io (SmartLogic LLC) — Tue, 22 Dec 2020 06:00:00 -0500

Today we sit down with Erlanger Viktória Fördős, who talks with us about Erlang and how it is used at Cisco. We open the show by finding out about Viki’s background in coding and her unorthodox entry into the field. After hearing about her experiences in her school choir and her transition into the informatics faculty, Viki talks to us about her first experiences in coding and the thrills she found in it. She then expands on the topic, revealing how she approached people to build their websites using her newfound skills in HTML and PHP. A flash-forward later, and Viki shares details about her role as an NSO Core Engineer for Cisco. After hearing how NSO serves as a network operating system, device automation platform, and orchestration engine, Viki explains why NSO is so special. She touches on fast map-based service and some of the ways she and her team implement network-wide transactions using — you guessed it — Erlang. Viki then explains Erlang, how you should approach it if you’re a newbie, and what to expect from its biggest challenges. She elaborates on tail-recursive functions and high-level vulnerabilities concerned with SSL crypto libraries, system integrity, and atom tables. Toward the end of the show, we ask Viki to tell us about her Code BEAM presentation and about her thoughts on why academia and industry should collaborate on a more regular basis. Join us today and be treated to an enriching conversation about Erlang, as well as our secret mini-feature segment!

Key Points From This Episode:

Introducing today’s guest, Viki Fördős from Cisco.
A snapshot of Viki’s unorthodox background in coding.
Viki shares details about early experiences learning Basic.
Hear about Viki’s first programming job out of college.
Viki’s position as a core engineer for the NSO team at Cisco.
Find out what the NSO team at Cisco does.
Insights into the patented algorithm, “fast map.”
How Viki started to use Erlang on a day-to-day basis.
Ways you can start thinking in Erlang from an Elixir background.
The kinds of issues Viki runs into when spawning too many processes.
What Erlang has to offer that other languages cannot.
Viki’s biggest challenges when she first started learning Erlang.
The elevator pitch Viki uses when she encourages friends and colleagues to use Erlang.
Distribution protocols and what they mean to Erlang newbies.
Hear about the high-level vulnerabilities you ought to pay attention to when coding in Erlang.
Introducing Christian Koch, today’s mini-feature segment guest.
How Chris first got into Elixir.
How Elixir is being used by platform engineers at Cars.com.
Why Elixir was chosen as the end-game language to be used at Cars.com
The process behind onboarding coders onto Chris’s Elixir team.
Viki’s best advice to those wanting to give a Code BEAM talk.
Hear about refactoring and how it works.
What Viki means by, “research being consumed by industry.”

Links Mentioned in Today’s Episode:

Viktória Fördős - https://github.com/viktoriafordos
Cisco — https://www.cisco.com/
EW20 — https://github.com/viktoriafordos/ew20 Prototype implementation of the security analysis introduced in V. Fördős: Secure Design and Verification of Erlang Systems paper
Christian Koch — https://www.linkedin.com/in/ckochx/
Cars.com — https://www.cars.com/
BASIC — https://en.wikipedia.org/wiki/BASIC
Cisco NSO — https://www.cisco.com/c/en/us/products/cloud-systems-management/network-services-orchestrator/index.html
Think in Erlang! - Viktória Fördős — https://www.youtube.com/watch?v=bYkOsQU2ywM
Erlang general server — https://erlang.org/doc/man/gen_server.html
Erland Reference Manual — https://erlang.org/doc/reference_manual/distributed.html
4 Using TLS — https://erlang.org/doc/apps/ssl/ssl_distribution.html
Erland System Limits — http://erlang.org/doc/efficiency_guide/advanced.html#system-limits
Hexdocs — https://hexdocs.pm/elixir/String.html#to_existing_atom/1
RefactorErl — https://plc.inf.elte.hu/erlang/
Pipedream on GitHub — https://github.com/PipedreamHQ/pipedream/blob/master/components/github/readme.md

Special Guest: Viktória Fördős.

Simon Glenn-Gregg on Building an Election Results Prototype in Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 17 Dec 2020 06:00:00 -0500

Today’s guest is Simon Glenn-Gregg, News Engineer at The Washington Post. He joins us to talk about using Elixir to build a prototype for a platform the news house recently implemented to visualize the results of the November 2020 elections in real-time.

While the job title of ‘News Engineer’ makes it seem like Simon invents news, this is not the case. He is focused on software related to publishing at The Washington Post, and in particular, has been working on building their election visualization platform for the past two years. Before the final iteration of the platform was built, the software engineering team at The Washington Post were given a period to test different technologies as an experiment to find the best fit, and Simon decided to try his hand at Elixir and Phoenix. He talks about what led him to this choice, and his experiences building out his prototype which he demonstrated on a dataset generated by the North Carolina 3rd Congressional District house race in September. Simon tells us about how the pitch went, what the team at The Washington Post was especially impressed by, and what led to the choice to use Node in the end.

Simon talks about the culture of openness to new technologies at The Washington Post as well as some of the limitations to their adoption. We also hear about how the final version of the visualization platform held up during the elections proper, and Simon’s plans to include Elixir in future stacks due to its amazing abilities as far as concurrency and memory. Tune in today!

Key Points From This Episode:

What kinds of projects Simon works on at The Washington Post as a ‘news engineer’.
The live updating election visualizer that Simon was working on at The Washington Post.
What went into building the infrastructure for this platform and how Elixir was chosen as a candidate.
A blog post about Elixir’s memory management; abilities Elixir has regarding concurrency.
The first steps Simon took toward learning Elixir and Phoenix by building simple projects.
Simon’s process of integrating his Elixir app into the current stack and people at The Washington Post.
Testing the app on the 3rd Congressional District house race in North Carolina, and pitching to the team.
Why it is hard to implement projects in new languages at The Washington Post.
How the voting process went after the pitch and which project won.
What the audience at the pitch loved about Elixir, and what the stumbling blocks were.
The nature of working at a deadline-driven place like The Washington Post when it comes to adopting new technologies.
Sources The Washington Post used to get their election data.
What technologies and methods the team used to handle the size of data some election moments generated.
Which parts about the election visualizer that ended up being built using Node would have been easier to do in Elixir.
The other side of the coin – what made writing the app in Python and JavaScript easier.
What future projects Elixir might be better suited to at The Washington Post.
Simon’s background, education, and how he learned programming in previous jobs
Why Simon stuck programming out and decided it was the right path for him.
The need for software engineers at The Washington Post and why they are recruiting so often.
A deep dive into the tech stack at The Washington Post and how they render their pages and maps.
How Simon feels having reached the end of a successful project that millions of people engaged with.
Future projects at The Washington Post and Simon’s hopes to incorporate more Elixir.
A funny story about having to manually update the votes from rural New Hampshire into the app.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Simon Glenn-Gregg on LinkedIn — https://www.linkedin.com/in/simongle/
Simon Glenn-Gregg — http://simonglenngregg.com/
The Washington Post — https://www.washingtonpost.com/
Jason Holt on Twitter — https://twitter.com/offpol
‘Elixir RAM and the Template of Doom’ — https://www.evanmiller.org/elixir-ram-and-the-template-of-doom.html
Erik Reyna on LinkedIn — https://www.linkedin.com/in/erikreyna/
Jeremy Bowers on LinkedIn — https://www.linkedin.com/in/jeremyjbowers/
Associated Press — https://apnews.com/
Edison — https://www.edisonresearch.com/
Whole Whale — https://www.wholewhale.com/
The Century Foundation — https://tcf.org/
Arc Publishing — https://www.arcpublishing.com/
Sundi Myint on Twitter — https://twitter.com/sundikhin
Justus Eapen — https://twitter.com/JustusEapen
Eric Oestrich on Twitter — https://twitter.com/ericoestrich

Special Guest: Simon Glenn-Gregg.

Randall Thomas on Learning Elixir and Why Community Matters

podcast@smartlogic.io (SmartLogic LLC) — Thu, 10 Dec 2020 06:00:00 -0500

The culture of your programming community directly impacts your professional success. As Thunderbolt Labs Founder Randall Thomas explains in this episode, a community that practices openness and which warmly welcomes its newer members leads to greater career happiness.

We open our chat with Randall by exploring his start in coding and how he discovered Elixir. He shares some of the teething problems that he had moving from Ruby to Elixir before we touch on how learning other languages expands your ability to both appreciate and code in languages that you’re already fluent in. Following this, Randall explodes the myth of the genius polyglot programmer by sharing his take on why all coders are polyglots. As the Thunderbolt CEO, we ask Randall how his company adopted Elixir. He provides listeners with insights into how they introduced Elixir into their practice without affecting existing projects.

After highlighting the efficiency of Elixir and how community affects the feel of a language, we compare the culture and challenges of Ruby, JavaScript, and Elixir. Near the end of the episode, Randall reflects on why experts make for poor teachers. For Randall, Elixir gives his company a competitive advantage. Tune in to hear Randall’s perspective on why community matters and for his top advice on teaching your team Elixir.

Key Points From This Episode:

Introducing Thunderbolt Labs Founder and CEO, Randall Thomas.
Randall shares how he discovered coding and engineering.
Hear how Randall first heard about Elixir and how he picked up the language.
Exploring common challenges moving from Ruby to Elixir.
How learning new languages can deepen your understanding of languages that you already know.
Why there’s no such thing as the ‘genius polyglot programmer.’
Details on why Randall’s company began gravitating towards Elixir.
How communities affect the ‘feel’ of a language.
Why no one actually writes in JavaScript anymore.
Randall gives his take on why Elixir is a god-send for certain programmers.
Insights into how Randall integrated Elixir into his company.
The challenge of learning Elixir versus the ease of learning JavaScript.
How Randall sold his clients on Elixir and the benefits of having clients that trust you.
Randall’s top tips on helping your developers learn Elixir.
Why Elixir gives Randall’s a strategic advantage.
The importance of having non-experts explain things to you.
How your coding community can impact your happiness and career success.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Randall Thomas on LinkedIn — https://www.linkedin.com/in/randall-j-thomas/
Randall Thomas on Twitter — https://twitter.com/daksis
Thunderbolt Labs — https://www.thunderboltlabs.com/
Episode with Miki Rezentes — https://smartlogic.io/podcast/elixir-wizards/s4e16-rezentes/
Gödel, Escher, Bach on Amazon — https://www.amazon.com/B6del-Escher-Bach-Eternal-Golden/dp/0465026567
Stephen Hawking — https://www.biography.com/scientist/stephen-hawking
William James — https://plato.stanford.edu/entries/james/
Bertrand Russell — https://plato.stanford.edu/entries/russell/
Barcelona Ruby Conference — https://twitter.com/baruco
José Valim — https://twitter.com/josevalim
Programming Elixir on Amazon — https://www.amazon.com/Programming-Elixir-1-6-Functional-Concurrent/dp/1680502999
Dave Thomas — https://pragdave.me/
ElixirConf — https://2020.elixirconf.com/
‘(UN)Learning Elixir’ — https://www.youtube.com/watch?v=o54EurlzK8o
Bruce Tate — https://www.linkedin.com/in/bruce-tate-a836b/
Grox.io — https://grox.io/
Eric S. Raymond — http://www.catb.org/~esr/
Stack Overflow — https://stackoverflow.com/
Medium — https://medium.com/
Engine Yard — https://www.engineyard.com/
Douglas Crockford — https://www.crockford.com/about.html
Yehuda Katz — https://www.linkedin.com/in/yehudakatz/
Blake Mizerany — https://www.linkedin.com/in/bmizerany/
The Pragmatic Studio — https://pragmaticstudio.com/
Stuff Goes Bad: Erlang in Anger on Amazon — https://www.erlang-in-anger.com/
Frederic Trottier-Hebert — https://www.linkedin.com/in/fredth/
Stu Holloway — https://www.linkedin.com/in/stu-holloway-linvio/
Paul Graham — http://www.paulgraham.com/
Hackers and Painters on Amazon — https://www.amazon.com/Hackers-Painters-Big-Ideas-Computer/dp/1449389554
Lonestar Elixir — https://lonestarelixir.com/
Turing.io — https://turing.io/
Sundi Myint on Twitter — https://twitter.com/sundikhin
Justus Eapen on Twitter— https://twitter.com/JustusEapen
Eric Oestrich on Twitter — https://twitter.com/ericoestrich

Special Guest: Randall Thomas.

Launchisode and Outlaws Takeover with Chris Keathley, Amos King, and Anna Neyzberg

podcast@smartlogic.io (SmartLogic LLC) — Thu, 03 Dec 2020 06:00:00 -0500

Welcome back to Elixir Wizards, season five, episode one! The theme for this season is ‘Adopting Elixir’, and for today’s show the team at Elixir Outlaws play host! Chris Keathley, Amos King, and Anna Neyzberg give the Elixir Wizards a chance to talk about what they love about Elixir, how they learned it, and some of their experiences using it at SmartLogic!

We kick off the conversation with some memories of college and the different degrees everybody did, how these experiences fit into programming and the different paths that Justus, Eric, and Sundi took into the world of Elixir. From there, we dive into some of the amazing features about Elixir, highlighting pattern matching, readability, and how easy it is to think about how to write solutions to problems using it. Our conversation moves onto the topic of serving clients with Elixir, and here we consider the risk of basing a consultancy on one technology, as well as how open clients are to their needs being met with this young but powerful language. We also talk about training staff and convincing teams to adopt Elixir, covering themes of barriers to entry, the job market, and using the Elixir community as a resource. For a fun conversation about Elixir where our hosts take the mic as guests, be sure to tune in today.

Key Points From This Episode:

Introducing this season’s topic and today’s plan where the hosts become guests.
How Justus, Eric and Sundi got introduced to Elixir and their respective journeys using it.
Everybody discusses their forays into programming and compares their different degrees.
Hustles Justus did at college to get tuition cheaper for his friends and him.
‘Staking a consultancy on a tech’; how SmartLogic adopted Elixir initially.
How the first few clients SmartLogic served with Elixir felt about the language being used.
Sundi’s onboarding experience at CAVA and how she got introduced to Elixir.
How Justus discovered the beauty of Elixir after he began to understand pattern matching.
Sundi’s thoughts about hidden functionality in JavaScript code versus Elixir which reads better.
Whether using Elixir to solve problems feels easy due to familiarity or its inherent characteristics.
Conventions SmartLogic is implementing regarding using Elixir to build projects.
The lack of introductory resources for learning Elixir and the team’s attempts at making some.
The value of getting involved in your community for learning a new technology.
Find out the value of investing in staff training for companies who want to switch to Elixir.
A new wall between Dev and Ops in the form of Kubernetes.
How to get your co-workers to learn Elixir if you are passionate about it.
Growth at SmartLogic, new hires, and what they specialize in.
The job landscape in 2020 and how this relates to having Elixir under your belt.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Chris Keathley on Twitter — https://twitter.com/chriskeathley
Amos King on Twitter — https://twitter.com/adkron
Anna Neyzberg on Twitter — https://twitter.com/aneyzb
Sundi Myint on Twitter — https://twitter.com/sundikhin
Justus Eapen — https://twitter.com/JustusEapen
Eric Oestrich on Twitter — https://twitter.com/ericoestrich
CAVA — https://cava.com/
Pavlok — https://pavlok.com/
Johnny Boursiquot — https://www.jboursiquot.com/
ElixirBridge — http://elixirbridge.org/
Matt Mills on GitHub — https://github.com/photomattmills
Brooklyn Zelenca on Functional Programming — https://smartlogic.io/podcast/elixir-wizards/s3e9-zelenka/
Bleacher Report — https://bleacherreport.com/
LiveView by Bruce Tate — https://pragprog.com/titles/passlive/programmer-passport-liveview/

Special Guests: Amos King, Anna Neyzberg, and Chris Keathley.

Season Four Wrap: Whose Design Is It Anyway? with Swadia, Windholtz, Rezentes, and Keathley

podcast@smartlogic.io (SmartLogic LLC) — Thu, 15 Oct 2020 06:00:00 -0400

To close off this season and conclude our deep dive into system and application architecture, today’s episode is a special panel discussion on a topic that has provoked a mix of answers that range from the controversial to the philosophical — “What does domain-driven design mean to you?” For the final word on this subject, we welcome back software developers Chris Keathley, Japa Swadia, Mark Windholtz, and Miki Rezentes. Our first hot take comes from Miki, who shares her thoughts about how domain-driven design developed because the tech industry undervalues communication. Following this, Mark and Japa discuss how domain-driven design gives developers a context for what they create while informing how you code using Elixir. We then touch on whether domain-driven design makes it easier or more difficult to change your code and how communication is valued within a business context. We explore key domain-driven design concepts, including the role of bounded contexts, and how this design ethos can help you appeal to stakeholders such as product managers. After Miki highlights the reasons why communication should be seen as a vital tech skill, each guest provides their final thoughts on domain-driven design. Tune in for this season’s insightful finale and find out which of today’s guests is the winner of “Whose Design Is It Anyway?”

Key Points From This Episode:

Introducing guests Chris Keathley, Japa Swadia, Mark Windholtz, and Miki Rezentes.
Hear what domain-driven design means for each guest.
Miki shares her hot take that domain-driven design is “nothing new under the sun.”
Why the essence of domain-driven design is about listening.
How domain-driven design can inform your Elixir architecture.
Mapping your system and developing names for your bounded contexts.
Domain-driven design trade-offs and how it can lead to a loss of productivity.
The idea that domain-driven design has developed because the tech industry undervalues communication.
Why communication should be valued — bad communication costs money.
How tech companies are generally aligned with the goals of domain-driven design.
Why Mark is so delighted to be working with Elixir and domain-driven design.
The link between domain-driven design and developing better products.
Exploring how bounded contexts allow teams to create solutions to unique problems.
Seeing communication as a tech skill that should be learned early in your career.
Our guests share their final thoughts on domain-driven design.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Chris Keathley on Twitter — @ChrisKeathley/
Chris Keathley — https://keathley.io/
Japa Swadia on Twitter — https://twitter.com/japa2292
Japa Swadia on LinkedIn — https://www.linkedin.com/in/japaswadia/
Mark Windholtz on Twitter — https://twitter.com/windholtz
Mark Windholtz on LinkedIn — https://www.linkedin.com/in/mwindholtz/
Miki Rezentes on Twitter — https://twitter.com/mikirez
Miki Rezentes on LinkedIn — https://www.linkedin.com/in/miki-rezentes-823ba02a/
Podium — https://www.podium.com/
Elixir Outlaws — https://elixiroutlaws.com/
Agile DNA — http://www.agiledna.com
Frame.io — https://frame.io/
Bleacher Report — https://bleacherreport.com/
Domain-Driven Design: Tackling Complexity in the Heart of Software on Amazon— https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
Domain Language — https://www.domainlanguage.com/
The Seven Laws of Learning: Why Great Leaders Are Also Great Teachers on Amazon
— https://www.amazon.com/Seven-Laws-Learning-Leaders-Teachers/dp/1599559277
Patterns, Principles, and Practices of Domain-Driven Design on Amazon — https://www.amazon.com/Patterns-Principles-Practices-Domain-Driven-Design/dp/1118714709
‘Ubiquitous Language’ — https://martinfowler.com/bliki/UbiquitousLanguage.html
‘Value Object’ — https://martinfowler.com/bliki/ValueObject.html
Domain-Driven Design Europe — https://dddeurope.com/2021/
Domain-Driven Design Europe on YouTube — https://www.youtube.com/channel/UC3PGn-hQdbtRiqxZK9XBGqQ
A Philosophy of Software Design on Amazon — https://www.amazon.com/Philosophy-Software-Design-John-Ousterhout/dp/1732102201
Eric Evans Training Videos — https://elearn.domainlanguage.com/
Designing Elixir Systems with OTP — https://www.amazon.com/Designing-Elixir-Systems-OTP-Self-healing/dp/1680506617/
Whose Line Is It Anyway? — https://www.imdb.com/title/tt0163507/
Drew Carey — https://www.imdb.com/name/nm0004804/

Special Guests: Chris Keathley, Japa Swadia, and Miki Rezentes.

Anna Sherman on Change, Failure, and living in Gig City

podcast@smartlogic.io (SmartLogic LLC) — Thu, 08 Oct 2020 06:00:00 -0400

Even with the most programming experience in the world, coding still involves a lot of trial and error. People getting started in the industry should not become bogged down by failure. Because in the end, it’s a feature and not a bug. That’s one of Zillion developer Anna Sherman’s key messages this episode. We open our discussion with Anna by talking about living in Chattanooga, AKA, Gig City. She talks about why the tech scene there is exploding before diving into her journey into programming. Having created her own personal coding boot camp, she opens up about what she did to land her first software job within only two months of looking. After discussing her early working experiences, we explore her work at Zillion, along with her side projects. We then touch on what Anna does to expand her skillset and develop herself as a professional, using a style guide and ‘lunch and learns’ to update her team, and we hear the elevator pitch for Anna’s Code BEAM San Francisco talk. Anna shares her take on architecture and design, as well as the importance of domain-driven design in keeping your team aligned with what they’re building. Near the end of the episode, we talk about Anna’s pre-coding process, the virtues of being a ‘physlistcler,’ and why failure is an important part of coding. Tune in to hear more of Anna’s insights on change, failure, and living in Gig City.

Key Points From This Episode:

Fast internet and the great outdoors; hear why Chattanooga has become a tech hub.
Anna shares her love of math and how she got into programming.
Creating your own boot camp and becoming a self-taught coder.
How Anna landed her first gig, just two months after learning code.
Exploring Anna’s first job at Sovee, a machine translation company.
What side projects Anna is working on and how they help her Magic: The Gathering games.
How Anna expands her skill set and develops herself as a professional.
Hear Anna’s elevator pitch for the talk she gave at Code BEAM San Francisco.
What architecture, design, and domain-driven design mean to Anna.
Using a style guide and ‘lunch and learns’ to help your team understand patterns.
Details on how Anna’s style guide keeps her team informed.
The virtues of being a ‘physlistcler;’ anchoring your workflow to a physical list.
Why failure is a key part of coding and the idea that anyone can learn to code.
We close the episode by chatting about Anna’s favorite board games.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Anna Sherman on LinkedIn — https://www.linkedin.com/in/anna-sherman-54289372/
Anna Sherman on Twitter — https://twitter.com/cavewoman90
Anna Sherman on Instagram — https://www.instagram.com/annasherman100816/
Anna Sherman Email — anna@myzillion.com
Craig Lyons Email — craig@myzillion.com
Zillion — https://www.myzillion.com/
Bruce Tate — https://twitter.com/redrapids
Brett Wise — https://twitter.com/brettwise
Gig City Elixir — https://www.gigcityelixir.com/
NervesConf — https://www.nervesconf.com/
Chili’s — https://www.chilis.com/
GodTube — https://www.godtube.com/
Magic: The Gathering — https://magic.wizards.com/en
Scryfall — https://scryfall.com/
Code BEAM SF Talk — https://www.youtube.com/watch?v=XgOJQAK6iHI
Evernote — https://evernote.com/
Nerves — https://www.nerves-project.org/
‘Repository and Services Pattern in a Multilayered architecture’ — https://www.vodovnik.com/2015/08/26/repository-and-services-pattern-in-a-multilayered-architecture/
A Handful of Stars — https://boardgamegeek.com/boardgame/197320/handful-stars
A Few Acres Of Snow — https://boardgamegeek.com/boardgame/79828/few-acres-snow

Special Guest: Anna Sherman.

Devon Estes on how Architecture Is a Myth and One-file Design

podcast@smartlogic.io (SmartLogic LLC) — Thu, 01 Oct 2020 06:00:00 -0400

There is no difference between architecture and design. It's all engineering and creating a distinction between the two is a way for someone to get paid more and have a different title. That hot take comes from Devon Estes, today’s guest, who provides a novel way of seeing design and architecture. We open the episode by diving straight into the topic of design, with Devon exploring how good design might be less important than developing the right toolset. We then talk about how language servers can help you effortlessly define functions, meaning that in some cases, it doesn’t matter where you put your code — even if it’s all in one file. After touching on game-changing innovations in the world of design, such as GTP-3, Devon shares how our design options are limited by our editors. Considering the impact of human error on software, we discuss the value of convention and rulesets. As Elixir apps or apps that use Phoenix are open-ended, Devon talks about his middle-ground solution to help teams overcome this challenge. Near the end of the episode, Devon chats about why design and architecture, as elements of engineering, are different levels of abstraction and not separate entities. Following this, he highlights how domain-driven design can be used to avoid confusion and bugs by ensuring that people across departments all use the same language. Tune in to hear more of Devon’s unique and well-pondered insights.

Key Points From This Episode:

Devon’s take on design; “Where things go doesn’t matter if you have a language server.”
Defining what a language server is and its incredible usefulness.
How ‘go to definition’ functions could render much of design as unnecessary.
Game-changing innovations that will change the world of design.
Functional versus object-orientated languages and the challenge of finding files.
Why Devon uses Vim and what makes it attractive to other programmers.
How Elixir apps can be a challenge due to their open-ended nature.
Creating primary and secondary contexts to give Phoenix more structure.
The human factor; why people are often the cause of many coding issues.
Hear how Devon has been structuring his Absinthe projects.
Devon shares details about his Absinthe testing library, Assertions.
Devon’s hot take that there is no difference between architecture and design.
The importance of domain-driven design in avoiding confusion and bugs.
Why engineers need to push to ensure the same language is used across departments.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Devon Estes — http://www.devonestes.com/
Devon Estes on GitHub — https://github.com/devonestes
Devon Estes on Twitter — https://twitter.com/devoncestes
Jake Becker on GitHub — https://github.com/JakeBecker
GPT-3 — https://www.independent.co.uk/life-style/gadgets-and-tech/news/gpt3-ai-tool-designs-websites-medicine-a9627966
Elixir Is — https://github.com/elixir-lsp/elixir-ls
Ale — https://github.com/dense-analysis/ale
MOO — https://lisdude.com/moo/
Erlang code — https://erlang.org/doc/man/code.html
‘A Proposal for Some New Rules for Phoenix Contexts’ — http://www.devonestes.com/a-proposal-for-context-rules
‘A proposal for an Absinthe application structure’ — http://www.devonestes.com/a-proposal-for-absinthe-project-structure
Elixir Radar — https://elixir-radar.com/
Assertions.Absinthe — https://hexdocs.pm/assertions/Assertions.Absinthe.html#document_for/4
ElixirConf EU — https://www.elixirconf.eu/
‘Elixir testing from beginner to expert’ — https://www.elixirconf.eu/trainings/elixir-testing-from-beginner-to-expert/

Special Guest: Devon Estes.

Lizzie Paquette on Compiling, Microliths, and Macros

podcast@smartlogic.io (SmartLogic LLC) — Thu, 24 Sep 2020 06:00:00 -0400

Imagine being hired into a rocketship startup using Elixir as its primary language. And all this, straight out of college. Today, we speak with systems software engineer, Lizzie Paquette who works at Brex, the aforementioned rocketship. We start our conversation by talking about how Lizzie got into coding relatively late in her life, partly due to an ill-fated run-in with Java. She shares details about her role at Brex and how the company has evolved. With a love of compilers, Lizzie dives into what beginners can do to get into compiling before chatting about her top underrated Elixir resources. Following this topic, Lizzie discusses her experience liberally implementing macros at Brex — something that ended up being detrimental when onboarding new hires. After sharing how she develops herself as a professional and coder, Lizzie talks about her involvement in Code 2040, a career accelerator and mentorship program.

Reflecting this season’s theme, we ask for Lizzie’s take on what architecture, design, and domain-driven design means to her. She then reveals her coding process and emphasizes the value of creating thorough design docs to avoid bugs. We explore Brex’s architecture, how it makes use of microliths, and applying ‘chaos engineering’ — a monkey-wrench approach to testing your system. We touch on umbrella apps and lessons that Lizzie’s learned from working with Brex’s architecture.

After closing our discussion with Lizzie, we open with another edition Pattern Matching with Todd Resudek and special guest Sophie DeBenedetto from GitHub. Todd asks Sophie about her favorite movies, music, and what Elixir projects excite her. Tune in to hear Sophie’s insights, along with more on microliths and macros from Lizzie Paquette.

Key Points From This Episode:

Lizzie shares how she got into coding and her start in the industry.
Hear about Lizzie’s role at Brex, a rocketship startup and key member of the Elixir community.
How novices should approach learning how to code compilers.
Underrated Elixir resources that Lizzie makes the most out of.
The double-edged sword; why macros are an incredible yet dangerous tool.
How Lizzie develops herself as a professional and a coder.
Boosting inclusivity in the software industry through programs like Code 2040.
Lizzie’s take on what architecture, design, and domain-driven design mean.
The value of design docs in catching bugs and laying out a clear process.
Microliths, microservices, and the nitty-gritty of Brex’s architecture.
Exploring ‘chaos engineering’; testing your system by purposefully creating problems.
Lizzie’s pain points when either using or not using umbrella apps.
What Lizzie would do if she could rewrite Brex’s architecture from scratch.
Using Brex.result to streamline code and handle common return values.
For this edition of Pattern Matching, Todd Resudek interviews Sophie DeBenedetto.
Sophie’s journey from liberal arts to learning software at a code boot camp.
Todd asks Sophie about her favorite movies, music, and what Elixir projects excite her.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Lizzie Paquette on LinkedIn — https://www.linkedin.com/in/lizzie-paquette/
Lizzie Paquette on GitHub — https://github.com/lizziepaquette
Brex — https://www.brex.com/
Eric Meadows Jonssön — https://twitter.com/emjii
Haskell — https://www.haskell.org/
Columbia University — https://www.columbia.edu/
Clash — https://clash-lang.org/
Framer — https://www.framer.com/
Elixir Protobuf on GitHub — https://github.com/brexhq/protobuf-elixir
Tony612 on GitHub — https://github.com/tony612
Elixir Syntax Reference — https://hexdocs.pm/elixir/syntax-reference.html
Metaprogramming Elixir: Write Less Code, Get More Done (and Have Fun!) — https://www.amazon.com/Metaprogramming-Elixir-Write-Less-Code/dp/1680500414
Macros in Elixir: Responsible Code Generation — https://www.youtube.com/watch?v=55-X7rSw8M0
Code 2040 — http://www.code2040.org/
Erlpack — https://github.com/discord/erlpack
Principles of Chaos Engineering — https://principlesofchaos.org/?lang=ENcontent
REST Fest 2019 | Lorinda Brandon — https://vimeo.com/364373007
‘Building a rewards platform from scratch’ — https://medium.com/brexeng/building-a-rewards-platform-from-scratch-ff4e22124658
Brex.result on GitHub— https://github.com/brexhq/result
RabbitMQ — https://www.rabbitmq.com/
Netflix Chaos Monkey on GitHub — https://github.com/Netflix/chaosmonkey
Mark Erickson — https://brainlid.org/
Johanna Larsson — https://blog.jola.dev/
Todd Resudek — https://twitter.com/sprsmpl
Sophie DeBenedetto — http://sophiedebenedetto.nyc/
Elixir School — https://elixirschool.com/en/
GitHub — https://github.com/
Flatiron School — https://flatironschool.com/
Barnard College — https://barnard.edu/
Law and Order — https://www.imdb.com/title/tt0098844/
Spotify — https://www.spotify.com/
Celine Dion — https://www.celinedion.com/
Hill Street Blues — https://www.imdb.com/title/tt0081873/
Perry Mason — https://en.wikipedia.org/wiki/Perry_Mason
Matlock — https://www.imdb.com/title/tt0090481/
Telemetry on GitHub — https://github.com/beam-telemetry/telemetry
Phoenix LiveView on GitHub — https://github.com/phoenixframework/phoenix_live_view

Special Guest: Lizzie Paquette.

Eric Steen on Neuroevolution in AI

podcast@smartlogic.io (SmartLogic LLC) — Thu, 17 Sep 2020 06:00:00 -0400

Building a sophisticated AI that can evolve to fit our vast and diverse needs is a Herculean challenge. Today we speak with senior engineer Eric Steen about Automata, his experimental Elixir project that uses neuroevolution and cutting edge theory to create a multi-agent behavior tree — or really good AI in the common tongue. But before we tap into that rich topic, we talk with Eric about tech burnout, his background, and why Elixir is an excellent language for writing modern software. He then unpacks AI concepts like the need to develop backpropagation in your system, and the value of “neural diversity,” and Markov decision processes.

After Eric gives his take on architecture versus design and the place of domain-driven design, we discuss Automata. A key breakthrough, Eric shares his enthusiasm for ‘novelty search,’ where machines learn from a variety of new behaviors and searches, as opposed to completing one task at a time. We touch on Automata’s progress, Eric’s long-term approach, and what his project might be used for. Near the end of our interview, we chat about CryptoWise, a collaborative analysis platform for cryptocurrency.

Todd Resudek then opens with another edition of Pattern Matching, where he interviews Whatsapp engineer Michał Muskała. They talk about Michał’s career, the movies and music that he enjoys, and the projects that excite him. Tune in to hear more about both Michał and neuroevolution in AI.

Key Points From This Episode:

Experiencing tech burnout and challenges around algorithms rendering you redundant.
Hear about Eric’s programming background and shifts in the industry.
Backpropagation and using Elixir to build a neural evolutionary system.
How Markov decision processes help systems choose between possible actions.
Eric’s take on architecture versus design and the place of domain-driven design.
Exploring Automata — Eric’s ambitious multi-agent behavior tree.
The importance of neurodiversity when building AIs; they need to adapt to many needs.
Novelty search; why learn through one task when you can learn through a variety of tasks at the same time?
Automata’s practical applications and why Eric sees it as a long-term project.
Eric shares a progress report on his work and using design processes like Sprint.
What Eric would like people to use Automata for.
A sense that Elixir is gaining in popularity within Silicon Valley.
Eric gives an elevator-pitch for CryptoWise, a collaborative analysis platform for cryptocurrency.
Todd Resudek interviews Michał Muskała on another edition of Pattern Matching.
Michał shares his background and his move from Poland to London.
Movies and music that Michał enjoys, and details on projects that excite him.
Differences between Erlang and Elixir and why both communities would benefit from working together.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Eric Steen on LinkedIn — https://www.linkedin.com/in/ericsteen1/
Eric Steen — https://twitter.com/the_steener
Webflow — https://webflow.com/
Automata GitHub — https://github.com/upstarter/automata
Automata on Slack — https://join.slack.com/t/automata-project/shared_invite/zt-e4fqrmo4-7ujuZwzXHNCGVrZb1aVmA
CryptoWise — https://www.cryptowise.ai/
Hippo Insurance — https://www.hippo.com/
Carl Hewitt — https://en.wikipedia.org/wiki/Carl_Hewitt
Stanford University — https://www.stanford.edu/
MIT — https://web.mit.edu/
Actor Model — https://en.wikipedia.org/wiki/Actor_model
Marvin Minsky — http://web.media.mit.edu/~minsky/
Tensorflex on GitHub— https://github.com/anshuman23/tensorflex
Matrex on GitHub — https://github.com/versilov/matrex
Handbook of Neuroevolution Through Erlang —
https://www.springer.com/gp/book/9781461444626
Markov Decision Process — https://en.wikipedia.org/wiki/Markov_decision_process
Amazon Web Services — https://aws.amazon.com/
The Little Elixir & OTP Guidebook — https://www.amazon.com/Little-Elixir-OTP-Guidebook/dp/1633430111
Elon Musk — https://www.forbes.com/profile/elon-musk/
Welcome to the Era of Deep Neuroevolution — https://eng.uber.com/deep-neuroevolution/
Kenneth O. Stanley — https://www.cs.ucf.edu/~kstanley/
Why Greatness Cannot Be Planned: The Myth of the Objective — https://www.amazon.com/Why-Greatness-Cannot-Planned-Objective/dp/3319155237/
University of Florida — https://www.ufl.edu/
Uber Air — https://www.uber.com/us/es/elevate/
Jeff Bezos — https://www.forbes.com/profile/jeff-bezos/
Sprint — https://www.thesprintbook.com/
Adobe — https://www.adobe.com/
Horde — https://www.horde.org/development/
Libcluster on GitHub — https://github.com/dsteinberg/libcluster
Swift for Tensorflow — https://www.tensorflow.org/swift
Triplebyte Blog — https://triplebyte.com/blog
EquiTrader — https://coinmarketcap.com/currencies/equitrader/
BloXroute Labs — https://bloxroute.com/
Holochain — https://holochain.org/
Michał Muskała on GitHub — https://github.com/michalmuskala
Jason on GitHub — https://github.com/michalmuskala/jason
Todd Resudek on LinkedIn — https://www.linkedin.com/in/toddresudek/
Whatsapp — https://www.whatsapp.com/
CERN — https://home.cern/
Ralph Kaminski — https://ralphkaminski.com/
Jayme Edwards — https://jaymeedwards.com/

Special Guest: Eric Steen.

Miki Rezentes on how it's APIs All the Way Down

podcast@smartlogic.io (SmartLogic LLC) — Tue, 01 Sep 2020 06:00:00 -0400

According to an ancient myth, the world rests on the back of a turtle. And what does that turtle stand on? Another turtle. It turns out that it’s turtles all the way down. Miki Rezentes, today’s guest, believes that all software rests on the back of APIs. Similar to the myth, it’s APIs all the way down. We open our conversation by discussing how homeschooling her children did more to prepare Miki for a software career than anything else she’s encountered. Miki shares highlights from her talk, ‘APIs All the Way Down’. This set up this episode’s key theme, that the tech industry is too concerned with how its software interacts to focus on how the people in its organizations communicate — their ‘human APIs.’ Following this, we ask Miki how she learns people’s APIs and we talk about the benefits of observation and mirroring. Tracking her career, we touch on how Miki transitioned from a homemaker to a developer before diving into her recent work at the data science platform Mode. She provides unique insights into how she views architecture and design and why the concept of domain-driven design doesn’t go far enough. We chat about how you can see your team as customers to promote domain-driven design and then drill into what she does to create a ‘shared pool of knowledge’ with her team. As Miki explains, ‘people problems’ are more difficult than technical ones and developers often make mistakes by not first developing common understanding. Especially when this relates to expectations within a company. Near the end of the episode, we explore what leaders can do to maintain productivity when growing their teams. Tune in to hear what you can do to deepen your team’s pool of understanding and improve the quality of your communication.

Note: this episode was recorded in late July when Miki was working at Mode; she is now a Senior Software Engineer at Frame.io.

Key Points From This Episode:

Why homeschooling her kids better prepared Miki for software development than anything else.
How people within an organization express themselves through individual APIs.
Understanding that people come from different backgrounds which influence their API.
The ‘shared pool of knowledge’ and figuring out how to communicate with people.
Miki’s journey from homemaker to becoming a software engineer.
How nobody really knows what they’re doing.
Security as a trade-off, privacy, and the power of two-factor authentication.
Hear about Miki’s work at the data science platform Mode.
What Miki enjoys most about working in Elixir and what she uses it for.
How Miki sees architecture and the differences between architecture and design.
Domain-driven design and the differences between data models and software.
Treating your team ‘Agilely’ and seeing them as your customers.
Miki’s process of developing a shared pool of understanding before hammering out the end-to-end components.
Why ‘people problems’ are much more difficult than development problems.
How tech companies misdiagnose ‘people problems’ as bad design.
Conway’s Law and how code production reflects an organization’s structure.
The importance of setting expectations to maintain productivity as a team grows in size.
The danger of the Peter principle; when people are promoted to their level of incompetency.

Links Mentioned in Today’s Episode:

Miki Rezentes LinkedIn —https://www.linkedin.com/in/miki-rezentes-823ba02a/
Miki Rezentes GitHub — https://github.com/mrezentes
Miki Rezentes Twitter — https://twitter.com/mikirez
Mode — https://mode.com/
SmartLogic — https://smartlogic.io/
Elixir Wizards Survey — smr.tl/podcastsurvey
Manning Publications — https://www.manning.com/
‘APIs All the Way Down’ — https://www.youtube.com/watch?v=hBpbEsAG4es
Turtles all the way down — https://en.wikipedia.org/wiki/Turtles_all_the_way_down
Crucial Conversations — https://www.amazon.com/Crucial-Conversations-Talking-Stakes-Second/dp/1469266822
Thomas Edison State University — https://www.tesu.edu/academics/online-degrees
Xkcd — https://xkcd.com/
Toshiba Global Commerce Systems — https://commerce.toshiba.com/
Kroger — https://www.kroger.com/
CA Technologies — https://www.ca.com/
Jira — https://www.atlassian.com/software/jira
ICFP 2020 — https://icfp20.sigplan.org/
James Edward Gray II — https://github.com/JEG2
Helix Data Engine - Mode — https://mode.com/helix/
Practical Object-Oriented Design in Ruby — https://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330
Tanium — https://www.tanium.com/
Poodr — https://www.poodr.com/
Gödel, Escher, Bach — https://en.wikipedia.org/wiki/G%C3%B6del,_Escher,_Bach
D'Aulaires' Book of Greek Myths — https://www.amazon.com/DAulaires-Greek-Myths-Ingri-dAulaire/dp/0440406943
The Mythical Man-Month — https://en.wikipedia.org/wiki/The_Mythical_Man-Month
Applying Conway's Law to improve your software development — https://www.thoughtworks.com/insights/blog/applying-conways-law-improve-your-software-development
Peter Principle — https://en.wikipedia.org/wiki/Peter_principle

Special Guest: Miki Rezentes.

ElixirConf 2020 Preview

podcast@smartlogic.io (SmartLogic LLC) — Thu, 27 Aug 2020 06:00:00 -0400

With ElixirConf 2020 just around the corner, today’s episode is a sneak peek where we talk with six of this year’s speakers. Each speaker gives listeners an elevator pitch of their talk while throwing in extra details about who their talk is aimed at, what they learned through the process, and which talks they’re excited about attending.

Our first guest is Quinn Wilton, a developer at Tinfoil Security, whose talk is titled ‘Type-Safe LiveView with Gleam’. Quinn explains how she’s created a symbiosis between Elixir and Gleam that helps her create more consistent code while offsetting the disadvantages of dynamic typing.

We then chat with Dan Lindeman whose talk, ‘Short Circuit IoT Development Time with Nerves,’ is an overview of building custom hardware using Nerves and Elixir.

After Dan’s plug on how you can start programming Nerves on your laptop, we welcome Jeffrey Utter to the show. His talk is a deep dive into ‘Debugging Live Systems on the Beam.’ Teasing out the topic, we discuss inefficiencies in the debugging process and how many developers adopt a ‘whack-a-mole’ approach to dealing with bugs.

From debugging to UintSet, Luciano Ramalho, our next speaker, gives us a taste of his presentation, ‘UIntSet: enumerable, streamable, understandable.’ Luciano shares how the Go language inspired him to experiment with leveraging protocols and streams to build new idiomatic Elixir data structures from scratch. He also touches on the importance of being humble when learning new languages and gearing Elixir to a non-engineer user base.

After Luciano, we’re joined by Melvin Cedeno, a fellow Elixir Wizard from the SmartLogic family. Melvin brings his teaching experience to bear on the topic of ‘Teaching Functional Programming with Elixir.’ This is a key talk in growing our community, especially when considering the point that being an Elixir genius doesn’t necessarily mean that you’re well-suited to teach it.

Last but certainly not least, we speak with Japa Swadia from Podium about her talk, ‘Domain-Driven Design with Elixir’ — a subject that’s been a huge focus on the podcast. We chat about what domain-driven design means and why it’s an important foundational concept for beginners to learn.

Tune in for this tip-of-the-iceberg preview. It’s just a glimpse into the varied and wonderfully informative talks you can expect at ElixirConf 2020.

Key Points From This Episode:

Introducing Quinn Wilton who is using Gleam to interact with Elixir.
How being acquired by Synopsys has given Tinfoil Security access to greater resources.
Balancing the advantages of Elixir with its drawbacks when it comes to dynamic analysis.
What Gleam is and how it makes static typing more approachable.
Teasing Quinn’s ElixirConf talk — ‘Talk Type-Safe LiveView with Gleam’
What Quinn has learned from the process of creating his presentation.
Building a dissembler and the talk that Quinn is most looking forward to attending.
Dan Lindeman’s work at Very making solar micro-grids.
The benefits of Elixir and Nerves when building custom hardware.
Who Dan’s talk is aimed at and why it’s appropriate for any experience level.
Working with smart minds and laboring through hardware docs that often lie.
How scary it can be to work with hardware and the value of having your talk appeal to entry-level Elixir users.
Jeffrey Utter unpacks his talk — ‘Debugging Live Systems on the Beam.’
How most people play ‘whack-a-mole’ when dealing with live system bugs.
Using match specs to hone in on your debugging process.
Why most Elixir coders should learn about Jeffrey’s debugging system.
Why is Recon Library is such an excellent tool and its potential uses in distributed systems.
Hear which talks Jeffrey is looking forward to attending.
How Go inspired Luciano Ramalho to explore applying different data structures to Elixir.
What skill-level Luciano’s talk is aimed at and why.
Developing a sense of how Elixir is idiomatic, despite being such a new language.
Being humble when learning new languages and the importance of protocols in understanding idiomatic data structures.
How Elixir is geared towards engineers which can create barriers of entry.
Mark Cedeno gives an elevator pitch for his talk — ‘Teaching Functional Programming with Elixir.’
Why knowing Elixir very well doesn’t mean that you can teach it.
The benefits of remote learning; it can make your teaching more organized and to-the-point.
Hear about the talks that Mark is excited about attending.
Japa gives us a crash-course on domain-driven design.
Creating a solid foundation for your app by considering the contexts in which it’s used.
Why beginners or those wanting to switch to domain-orientated coding should attend Japa’s talk.
Using schema to point to the same table in different contexts.
Which talks Japa is attending and how she got selected for ElixirConf 2020.

Links Mentioned in Today’s Episode:

Special Guests: Dan Lindeman, Japa Swadia, Jeffrey Utter, Luciano Ramalho, Melvin Cedeno, and Quinn Wilton.

Mark Windholtz on Domain-Driven Design (DDD)

podcast@smartlogic.io (SmartLogic LLC) — Thu, 20 Aug 2020 06:00:00 -0400

Domain-driven design and extreme programming can help bridge the gap between development and business, and today we invite Mark Windholtz from Agile DNA to talk about how! Mark starts out by telling us about his early work in extreme programming before agile was a term and how he switched from Rails to Elixir after realizing its power for implementing domain-driven design. We take a deep dive with him into what these concepts mean, hearing him weigh in on how DDD can help architecture accommodate both development and business oriented complexities. For Mark, development and business teams must get a better understanding of each other’s jargon, and DDD is a way to accomplish this. The goal is to find a way of building a solid software core and to move away from features to systems thinking, whereby flexible software can make it more possible to do agile on the business side. We chat about some of the practices and principles that come into play when implementing DDD for Mark, and he details concepts like ubiquitous language, bounded contexts, and how to focus on the core domain by exploring models using tactical and strategic patterns. Along with this, Mark discusses users not being a domain concept, the challenges of getting new terms to stick in teams’ minds, and the task of refactoring code to reflect updated glossaries. Near the end of our conversation, Mark drills down on how DDD can optimize team efficiency. In closing, we get to know Chris Bell from ElixirTalk a little better in this week’s edition of Pattern Matching with Todd!

Key Points From This Episode:

Thoughts on SpaceEx and their approach to engineering: system versus feature optimization.
Mark’s background in extreme programming, how he got started with AgileDNA, and the work they do there.
A definition of extreme programming that adds engineering practices to Scrum.
Elixir’s superior ability to do DDD compared to Rails and how Mark got started using it.
A brief introduction to domain-driven design, an approach to simplifying complex software.
How architecture needs to accommodate essential as well as accidental complexity.
Elixir’s ability to accommodate the building of domain models with well-separated code chunks.
Principles of ubiquitous language and bounded contexts that make up DDD for Mark.
Ubiquitous language helps devs and businesspeople understand each other.
Bounded contexts: ‘Within this space, this world means this thing.’
Shifting focus from trying to make not all software, but core software, good.
What patterns are applied to use principles of ubiquitous language and bounded contexts.
Finding and focusing on the core domain by exploring models and how to do this using tactical and strategic patterns.
The consequences of users not being a domain concept which demands having a clearer language.
Challenges of getting language and concepts to stick in business people’s minds.
Refactoring code to reflect updated glossaries: Technical challenges teams doing DDD face.
Switching paradigms from feature-based optimizations to building an amazing code core.
Approaches to modeling: the value of exploring multiple models.
How teams can become more efficient using DDD and extreme programming.
Final plugs from Mark and how Agile DNA can help use Elixir to implement DDD.
Pattern matching: Todd gets to know more about Chris Bell from ElixirTalk.
How Chris got into programming, what he’d do if not be a programmer, and more!
Why Chris loves history, dream pop, and what movie he’ll watch over and over.
What project Chris is most excited about next: Building Settlers of Catan using LiveView.

Links Mentioned in Today’s Episode:

Elixir Wizards Listener Survey — https://smr.tl/podcastsurvey

SmartLogic — https://smartlogic.io/
Mark Windholtz on LinkedIn — https://www.linkedin.com/in/mwindholtz/
Mark Windholtz on Twitter — https://twitter.com/windholtz
Agile DNA — http://www.agiledna.com
Chris Bell on Twitter — https://twitter.com/cjbell_?lang=en
ElixirTalk — http://elixirtalk.com/
Chris Keathley — https://keathley.io/
Elon Musk — https://www.forbes.com/profile/elon-musk/#5bbe73cc7999
The Everyday Astronaut — https://www.youtube.com/channel/UC6uKrU_WqJ1R2HMTY3LIx5Q
Rob Martin — https://www.linkedin.com/in/version2beta/
Perhap — https://github.com/Perhap/perhap
Andrew Hao — https://github.com/andrewhao
Fred Brooks — http://www.cs.unc.edu/~brooks/
The Mythical Man-Month — https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959
Zach Thomas — https://github.com/zdcthomas?language=elixir&tab=stars
1917 — https://www.imdb.com/title/tt8579674/
Real Estate — https://www.realestatetheband.com/
Galaxie 500 — https://pitchfork.com/artists/1673-galaxie-500/
Star Trek: First Contact — https://www.imdb.com/title/tt0117731/
Star Trek: The Wrath of Khan — https://www.imdb.com/title/tt0084726/
LiveView — https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
Lonestar Elixir — https://lonestarelixir.com/

Special Guest: Mark Windholtz.

Elixir Wizards Dojo: Nerves Part 2 with Connor Rigby and Todd Resudek

podcast@smartlogic.io (SmartLogic LLC) — Thu, 13 Aug 2020 06:00:00 -0400

Welcome to the second part of our special Elixir Wizards Dojo. A mashup made in partnership with ElixirConf Japan. In today’s episode, we talk to Nerves core team members Todd Resudek and Connor Rigby about all things Nerves. But first, Todd leads us into a delightful digression about his enjoyment of heavy metal music. From metal back to Nerves, Todd chats about how he uses Nerves to monitor his internet connection and to automatically restart his router when certain conditions are met. After talking about using Flutter and Dart to build GUIs, we ask Todd to share another of his Nerves projects; the future of sprinklers — the Drizzle 2000! We then explore Connor’s self-defined role in the Nerves team as the development head of networking libraries before discussing how easy it is to use Nerves if you are an Elixir user. Todd and Connor dive into their utopian visions for the future of Nerves and why no other IoT solutions can compete with the tooling that Nerves provides. We talk about FarmBot and the many features that its models have, including how they can pulverize weeds. This springboards the conversion into the increasing importance of IoT tech in the agriculture sector and how it’s likely to be the next billion-dollar industry. We round off the episode by giving our guests the space to plug themselves and they close with a request for listeners to Iron Maiden and Metallica’s first albums. A perfect compliment to the first installment of the Elixir Wizards Dojo, tune in to learn more about the Nerves Project.

Key Points From This Episode:

Introducing our guests and this episode’s connection to ElixirConf Japan.
Connor and Todd lead a chat on the history and subgenres of heavy metal music.
Todd talks about using Nerves to monitor his internet connection and restart his router.
Building a user interface for Nerves’s projects using Flutter; Google’s UI toolkit.
Best practices for developing apps with a specific focus on GUI apps.
Hear about the Drizzle 2000! Todd’s sprinkler controller system that runs on Nerves.
Todd and Connor’s respective roles as a part of the Nerves core team.
The benefit of using Nerves; once it’s booted it’s a regular Elixir app.
What a kiosk terminal is and how you would go about internationalizing one.
Exploring the future of Nerves and hardware development.
Comparing Nerves to other IoT solutions; in conclusion, nothing can compete.
Different FarmBot system models that all use Nerves to grow food for you.
Using Nerves to encode and record video or to create a live stream.
Why integrating IoT into the agricultural sector will be the next billion-dollar industry.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
ElixirConf — https://elixirconf.com/2020
Connor Rigby GitHub — https://github.com/ConnorRigby
Todd Resudek Twitter — https://twitter.com/sprsmpl
Todd Resudek GitHub — https://github.com/supersimple
Simplebet — https://simplebet.io/
Flutter — https://flutter.dev/
Binary Noggin — https://binarynoggin.com/
Nerves Project — https://www.nerves-project.org/
Nerves Project GitHub — https://github.com/nerves-project/nerves_pack#erlang-distribution
Nerves Vintage Net GitHub — https://github.com/nerves-networking/vintage_net
Nerves Web Kiosk GitHub — https://github.com/nerves-web-kiosk/kiosk_system_rpi3
Rhapsody of Fire — https://www.rhapsodyoffire.com/
Ronnie James Dio — https://www.ronniejamesdio.com/
DragonForce — https://dragonforce.com/
Black Sabbath — https://www.blacksabbath.com/
Deep Purple — https://deeppurple.com/
Iron Maiden — https://ironmaiden.com
Judas Priest — http://www.judaspriest.com/home/
Sam Dunn — https://www.imdb.com/name/nm0242757/
Ryan Holiday — https://ryanholiday.net/
Arjen Lucassen — https://www.arjenlucassen.com
Metallica — https://www.metallica.com/
San Francisco Symphony — https://www.sfsymphony.org/
Fping — https://fping.org/
Dart — https://dart.dev/
React Native — https://reactnative.dev/
Scenic — https://kry10.com/
Phoenix Framework — https://www.phoenixframework.org/
Drizzler 2000 GitHub — https://github.com/supersimple/drizzle
Ditch Witch — https://www.ditchwitch.com/
Jon Carstens — https://twitter.com/joncarstens?lang=en
Le Tote — https://letote.com/
Electron — https://www.electronjs.org/
Matthew Ludwigs — https://www.linkedin.com/in/mattludwigs/
SmartRent — https://smartrent.com/
Sophie Debenedetto — http://sophiedebenedetto.nyc/
FarmBot — https://farm.bot/
Membrane Framework — https://www.membraneframework.org/
Greg Mefford — https://www.linkedin.com/in/ferggo/
Omni-eye GitHub — https://github.com/GregMefford/omni_eye
Bowery Farming — https://boweryfarming.com/
John Deere — https://www.deere.com

Show Notes - Japanese

Elixir Wizards Dojo 第2部 Connor Rigby と Todd Resudek

Episode S4E13b: 概要

Elixir Wizards Dojo スペシャル番組の第二部にようこそ。ElixirConf JPとのパートナーシップによるマッシュアップです。今日のエピソードでは、NervesコアチームのメンバーであるTodd Resudek と Connor Rigby とNervesの全てについて話します。でも最初に、Toddは私たちをヘビーメタル音楽の彼の楽しみについての楽しい余談に導きます。メタルからNervesに戻って、ToddはNervesをインターネット接続のモニタリングと、特定の条件が満たされた時にルーターの自動で再起動する方法について話します。FlutterとDartを使ってGUIを構築する方法について話したあと、Toddに彼の作ったもう一つのNervesプロジェクト、スプリンクラーの未来，Drizzle 2000！についてシェアしてもらいます。そしてConnorがNervesチームにおける自ら定義した役割である、ネットワーキングライブラリの開発について探求し、もしElixirユーザーである場合にNervesを使うことがいかに簡単かについて議論します。ToddとConnorはNervesの未来の理想郷についての話題と、Nervesが提供するツールに敵うIoTソリューションが他に存在しない理由について飛び込みます。ファームボットについて話をして、雑草をやっつける機能を含む、ファームボットのモデルが持つたくさんの機能について話します。これは、農業分野でのIoT技術の重要性の高まりへの転換と、どのように次の10億ドル規模の産業になる可能性が高まってくるかについてを示しています。エピソードの締めくくりは、ゲストに自分自身とつながる方法について紹介してもらいながら、アイアンメイデン(Iron Maiden)とメタリカ(Metallica)のファーストアルバムをリスナーに紹介します。Elixir Wizards Dojoの初回への謝辞から、Nervesプロジェクトの詳細を学んでください。

このエピソードのみどころ

ゲストの紹介と、このエピソードとElixirConf JPとのコネクションについて
Connor と Todd によるヘビーメタル音楽の歴史とサブジャンルへの案内
ToddのNervesを使ったインターネット接続のモニタリングとルーターの再起動の
Fultter というGoogleのUIツールキットを使ったNervesプロジェクトのユーザインタフェース構築
GUIアプリに焦点を当てたときのアプリ開発のベストプラクティス
Drizzle 2000について聴ける！ Nervesで動くToddのスプリンクラーコントローラシステム
ToddとConnorのNervesコアチームにおけるそれぞれの役割
Nervesを使う利点: 一度起動すると通常のElixirアプリになる
キオスク端末とは何か，どのようにキオスク端末を国際化するか
Nervesとハードウェア開発の将来の探求
Nervesと他のIoTソリューションの比較: 結論としては，Nervesに敵うものはない
ファームボットシステムのモデルの違いについて: 全てにNervesが使われていて、食糧を育てる
Nervesを使ってビデオをエンコードしたり録画したり，ライブストリーミングしたりする方法
IoTを農業分野に統合することが次の10億ドル産業になる理由

Special Guests: Connor Rigby and Todd Resudek.

Elixir Wizards Dojo: Nerves Part 1 with Frank Hunleth and Justin Schneck

podcast@smartlogic.io (SmartLogic LLC) — Tue, 11 Aug 2020 06:00:00 -0400

Welcome to the first part of our extra special Elixir Wizards Dojo. A mashup made in partnership with ElixirConf Japan, in today’s episode, we pose questions asked by the Japanese Nerves community to Nerves core team members, Frank Hunleth and Justin Schneck. After introducing our guests, we talk about which companies make use of Nerve and explore its use cases by looking at FarmBot, an open source robotic farming tool. Justin and Frank take turns explaining the differences between soft and hard real-time — a springboard to show how Nerve excels within its ‘middle-ground of complexity’, production-orientated niche. From Halloween pranks to growing Sichuan chili peppers in the office, Justin and Frank share the projects that they’ve built using Nerves and emphasize its wide applicability. We discuss how Nerves has been both officially and unofficially ported to different devices, why people send Frank random pieces of hardware in the mail, and the differences between open-source and making your work publicly available. Justin and Frank commiserate over the challenge of working with Bluetooth and the beauty of the Nerves community in pushing innovation. We chat more about Nerves, including how you can extend the functionality of file systems, before Justin and Frank unpack their roadmap for Nerves’s future. Tune in to learn more about the Nerves Project, a system that can add a great deal of agility to any development cycle.

Key Points From This Episode:

Introducing our guests and this episode’s focus on the Japanese Elixir community.
The double-edge of broadcasting your excitement about Elixir projects.
Looking at FarmBot as a practical use-case to show off what Nerve can do.
Differences between soft and hard real-time using FarmBot as an example.
What Nerves excels at; acting as a gateway for other processors.
Justin and Frank share the projects that they’ve built using Nerves.
A brief digression where Justin shares his love of Chinese Sichuan cooking.
What other markets are making use of Nerves in their product cycle.
The unique ‘middle-ground’ of complexity that Nerves is best suited to address.
Porting Nerves to different devices and what devices need to run Nerves.
Open-source versus making work public and how Justin took some of his Bluetooth work public.
The challenges of working with Bluetooth.
Hear how a group in the community is making a Nerves keyboard.
How you can extend the functionality of a file system on Nerves.
Nerves’s features that make it such an excellent tool within a production environment.
When deploying with Nerves Hub, learn how to configure Wi-Fi modules with different devices.
Starting with a facelift, Frank and Justin share their roadmap for Nerves’s future.
How companies Vary and SmartRent have contributed to the longevity of Nerves.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
ElixirConf — https://elixirconf.com/2020
Frank Hunleth — https://www.linkedin.com/in/fhunleth/
Justin Schneck — https://www.linkedin.com/in/justinschneck
Susumu Yamazaki — https://twitter.com/zacky1972
Nerves Project — https://www.nerves-project.org/
Nerves Project Open Collective — https://opencollective.com/nerves-project
Nerves Project GitHub — https://github.com/nerves-project/nerves_pack#erlang-distribution
Nerves Kiosk System GitHub — https://github.com/nerves-web-kiosk/kiosk_system_rpi3
FarmBot — https://farm.bot/
Rose Point — https://www.rosepoint.com/
The Food of Sichuan — https://www.amazon.com/Food-Sichuan-Fuchsia-Dunlop/dp/1324004835
Lance Halvorsen — https://www.linkedin.com/in/lance-halvorsen-07a102/
Atom VM GitHub — https://github.com/bettio/AtomVM
Lichee Pi Zero — https://licheepizero.us/
Pavlok — https://pavlok.com/
Harald GitHub — https://github.com/verypossible-labs/harald
Bluetooth with Nerves Notes GitHub — https://gist.github.com/fhunleth/fae46998609814ae4a8abd44f6f08188
Fwup GitHub — https://github.com/fhunleth/fwup
‘Building a keyboard with Elixir’ — https://medium.com/swlh/building-a-keyboard-with-elixir-fc7bd3f60ec3
Vintage Net Wizard GitHub — https://github.com/nerves-networking/vintage_net_wizard
Grizzly GitHub — https://github.com/smartrent/grizzly
SmartRent Careers — https://smartrent.com/careers/
Very Possible Careers — https://www.verypossible.com/careers

Show Notes - Japanese

Elixir Wizards Dojo 第一部 Frank Hunleth と Justin Shneck

Episode S4E13a: 概要

Elixir Wizards Dojo スペシャル番組の第一部にようこそ。ElixirConf JPとのパートナーシップによるマッシュアップです。今日のエピソードでは、日本のNervesコミュニティからの質問をNervesコアチームのメンバーであるFrank Hunleth と Justin Schneck に尋ねます。ゲストの2人を紹介した後、Nervesを使用する会社のことや、ファームボット(オープンソースのロボティック農業ツール)に見る使用事例を探ります。JustinとFrankが交互にソフトリアルタイムとハードリアルタイムの違いを説明し、Nervesが「複雑さの中立的立場」、生産指向のニッチという点で優れていることを示します。ハロウィンのいたずらから、オフィスで育つ四川の唐辛子栽培まで、JustinとFrankはNervesを使用して構築したプロジェクトを紹介し、その幅広い応用性を強調します。Nervesが公式・非公式にさまざまなデバイスに移植された方法についてや、なぜみんながFrankにランダムなハードウェアを郵送するのか、オープンソースと単に作品を公開することの違いについて話し合います。JustinとFrankはBluetoothの機能開発の課題に同情し、イノベーションを推進する上でのNervesコミュニティの美点について語ります。さらにNervesについて話が進み、どのようにファイルシステムの機能性を拡張するのかや、JustinとFrankがNervesの将来のロードマップについて披露します。どのような開発サイクルにも「アジャイルに」できるシステムである、Nerves プロジェクトについてより詳しく知りたいという人は、是非聴いてください。

このエピソードのみどころ

ゲストの紹介と、日本のElixirコミュニティに対するこのエピソードの焦点
Elixirプロジェクトについての興奮を広める上での「両刃」
ファームボットに見るNervesが実現できる実事例
ファームボットを例にした、ソフトリアルタイムとハードリアルタイムの違い
Nervesの何が優れているのか: 他のプロセッサへのゲートウェイの役割
JustinとFrankが共有する、Nervesで今まで構築してきたプロジェクトの数々
Justinが愛する四川料理についての軽い脱線
Nervesを製品サイクルに応用する他のマーケットや事例
Nervesが扱うのに手ごろな複雑さの独特の「中間基盤」
Nervesの異なるデバイスへの移植とNervesを実行させるのにどんなデバイスが必要
オープンソースと作品を公開することの違いと、どのようにJustinがBluetoothでの仕事の一部を公開したか
Bluetoothの開発作業のチャレンジ
コミュニティのグループがどのようにNervesキーボードを作っているか
どのようにNervesのファイルシステムの機能性を拡張するか
本番環境で優れたツールとなる上でのNervesの機能

Special Guests: Frank Hunleth and Justin Schneck.

Greg Mefford on Nerves, Poncho vs Umbrella Apps, and Pre-Code Planning

podcast@smartlogic.io (SmartLogic LLC) — Thu, 06 Aug 2020 06:00:00 -0400

In today’s episode, we chat about system architecture, Ruby, Elixir, and everything in between with Greg Mefford, the senior back-end engineer for the Bleacher Report. We open the conversation by asking Greg about his start in coding, leading to a story about how Greg was that bored kid pressuring a math teacher to teach him QBasic. He shares how he fell in love with Ruby before discovering Elixir and Nerves. Having faced some challenges when learning Nerves, Greg talks about how he began documenting his pain points and writing documents to help onboard newcomers. We discuss Greg’s work with Nerves, his project aspirations, and his recommended resources for anyone looking to get into Nerves or Elixir. After providing his hot take on the latest Code BEAM V conference, we ask Greg what system architecture means to him. From there we get super meta about the meaning of architecture and what it means to translate design into practice. We touch on the struggle of understanding domain-driven design and Greg’s approach to pre-code planning before delving into how the Bleacher Report is set up. As Greg goes into details, you’ll hear why their servers now run on Elixir and not Ruby. Near the end of the episode, we talk about Poncho versus Umbrella apps, and Greg shares his passion for multi-user dungeons (MUDs). Tune in to learn more about Greg and his role in the Elixir and Nerves landscape.

Key Points From This Episode:

Greg’s start in coding and his transition from electronics design into IT.
Why Greg loves Ruby and how he discovered the magic of Elixir.
Greg’s contribution to the Elixir and Nerves community by helping onboard newcomers.
What Greg’s job as a senior engineer for Bleacher Report looks like.
Greg recommends resources for beginners getting into Nerves and Elixir.
Creating a kid’s game using Nerves and Greg’s Blinkchain library.
Greg’s take on the Code BEAM V conference and hating on the Whova app.
What architecture means to Greg. This one gets deep.
How translating designs into software has changed over the years.
Why Greg struggles with the idea of domain-driven design.
The state of Extreme Programming practices and how they synergize together.
How Greg views pre-code planning; something that’s become his specialty within his latest job.
The many elements that contribute to how the Bleacher Report’s IT is set up.
Ruby servers versus Elixir servers and why the Bleacher Report uses Elixir.
Why the Poncho system was designed to fix Nerves issues not covered by Umbrella apps.
Greg’s history creating multi-user dungeons (MUDs) and playing DragonRealm.

Links Mentioned in Today’s Episode:

Greg Mefford LinkedIn — https://www.linkedin.com/in/ferggo/
SmartLogic — https://smartlogic.io/
SmartLogic Jobs — https://apply.workable.com/smartlogic/
ElixirConf — https://elixirconf.com/2020
Blinkchain GitHub — https://github.com/GregMefford/blinkchain
Justin Schneck GitHub — https://github.com/mobileoverlord
Le Tote — https://www.letote.com/
James Smith — https://twitter.com/st23am
Garth Hitchens, ElixirCof 2015 — https://www.youtube.com/watch?v=kpzQrFC55q4
Nerves Project — https://www.nerves-project.org/documentation
Bleacher Report — https://bleacherreport.com/
Programming Elixir — https://www.amazon.com/Programming-Elixir-1-6-Functional-Concurrent/dp/1680502999
Elixir in Action — https://www.amazon.com/Elixir-Action-Sa%C5%A1a-Juri-cacute/dp/1617295027
Chris Keathley — https://codesync.global/speaker/chris-keathley/
Code BEAM V Conference — https://codesync.global/conferences/code-beam-sto/
Whova App — https://whova.com/
Amos King — https://twitter.com/adkron?lang=en
Christopher Keele — https://github.com/christhekeele
Steve Bussey Episode — https://smartlogic.io/podcast/elixir-wizards/s4e3-bussey/
Mark Windholtz — https://github.com/mwindholtz
Extreme Programming — http://www.extremeprogramming.org/
Adopting Elixir: From Concept to Production — https://www.amazon.com/Adopting-Elixir-Production-Ben-Marx/dp/1680502522
Live Elixir Wizards - Betweenisode — https://www.youtube.com/watch?v=kEwxhGYEGts
Twirp GitHub — https://github.com/twitchtv/twirp
Frank Hunleth — https://github.com/fhunleth
Elixir Supervisor Behavior — https://hexdocs.pm/elixir/Supervisor.html
Elixir Poncho Projects — https://embedded-elixir.com/post/2017-05-19-poncho-projects/
Titans of Text — https://www.titansoftext.com/
Miriani — https://www.toastsoft.net/
DragonRealms — https://www.play.net/dr/
Justus Eapen Twitter — https://twitter.com/justuseapen
Eric Oestrich — https://twitter.com/EricOestrich

Special Guest: Greg Mefford.

Johanna Larsson on Hex Diff, Domain Driven Design, Umbrella apps, and more

podcast@smartlogic.io (SmartLogic LLC) — Mon, 27 Jul 2020 06:00:00 -0400

Johanna Larsson is a community-minded software engineer whose project, Hex Diff, generates highlighted git diffs, right in your browser. In this episode, we talk to Johanna about how Hex Diff can benefit Elixir users, the differences between code architecture and code design, and the debatably under-appreciated role of Elixir umbrella apps. We start the conversation by chatting with Johanna about her recent move to London and her work for Duffel; a startup helping travel agencies book trips. After talking about how she got into software development, we dive into Hex Diff versus GitHub, with Joanna detailing how Hex Diff offers greater security for your code. We ask Johanna about the origins of the Hex Diff project and she explores its aims and her experiences working on the project. In line with this month’s theme, we discuss what architecture means to Joanna and the need for domain-driven design. We quiz Joanna on her approaches to problem-solving and she explains how her coding process emphasizes building an early prototype and constantly iterating on it. Despite hearing that umbrella apps are bad news, Joanna makes a case for their value while acknowledging how that they need greater tooling. We round off our conversation by asking Joanna how she tries to grow her skillset and what her favorite Elixir resource is. Following our discussion with Johanna, we open with another edition of Pattern Matching with Todd. This week, friend of the podcast Todd Resudek asks five questions of Elixir community member Bruce Williams. They talk about Bruce’s work as an Arabic cryptologic linguist for the US Airforce, his software career, and the therapeutic uses of playing Animal Crossing during a pandemic.

Key Points From This Episode:

We introduce Johanna Larsson and she shares how she is doing in London.
How Johanna developed a love for software and how Elixir brought her to London.
Details about Johanna’s job at Duffel; a startup that helps travel companies book trips.
How Hex Diff is solving problems that arise when using code from GitHub.
Johanna’s experience working on Hex Diff and the problems that they aim to solve.
Hex Diff’s caching system and what Hex Diff does to counter malicious software uploads.
The disconnect between system architecture and implementation.
Johanna’s view on the differences between code design and code architecture.
Why domain-driven design increases usefulness to the end-user.
How Johanna approaches a problem and her steps when building code.
Hear what key lesson Johanna learned from her latest big project.
Johanna’s experience with umbrella apps and why they need tooling functions.
How working in a strong team can motivate you and help grow your skill set.
Why the Elixir Slack group is Johanna’s favorite tool.
Why you should check out Hex Diff; it’s a great introduction to Elixir.
This edition of Pattern Matching with Todd; Todd Resudek interviews Bruce Williams.

Links Mentioned in Today’s Episode:

Johanna Larsson — https://blog.jola.dev/
Johanna Larsson LinkedIn — https://www.linkedin.com/in/joladev/
Johanna Larsson Twitter — https://twitter.com/joladev
SmartLogic — https://smartlogic.io/
ElixirConf — https://elixirconf.com/2020
SharePoint — https://www.microsoft.com/en-us/microsoft-365/sharepoint/collaboration
Duffel — https://duffel.com/
Stripe — https://stripe.com/
Hex Diff — https://diff.hex.pm/
Hex Diff GitHub — https://github.com/hexpm/diff
Maciej Mensfeld — https://mensfeld.pl/
Diffend — https://my.diffend.io/
Wojtek Mach — https://twitter.com/wojtekmach
Eric Meadows-Jönsson — https://twitter.com/emjii
Todd Resudek — https://twitter.com/sprsmpl
Announcing Hex Diff — https://hex.pm/blog/announcing-hex-diff
Hex Core GitHub — https://github.com/hexpm/hex_core
Hex Diff Phoenix — https://diff.hex.pm/diff/phoenix/1.5.2..1.5.3
The Design of Everyday Things — https://www.amazon.com/Design-Everyday-Things-Revised-Expanded/dp/0465050654
Brooklyn Zelenka LinkedIn— https://www.linkedin.com/in/brooklynzelenka/
Unified Modeling Language — https://en.wikipedia.org/wiki/Unified_Modeling_Language
Elixir v. 1.10.4 Mix CMD — https://hexdocs.pm/mix/Mix.Tasks.Cmd.html
Elixir v1.11 Forum Post — https://elixirforum.com/t/elixir-v1-11-will-be-released-in-october-2020/31535
Rustler GitHub — https://github.com/rusterlium/rustler
Live View —https://blog.codepen.io/documentation/live-view/
Bruce Williams — https://www.linkedin.com/in/wbruce/
Absinthe — https://absinthe-graphql.org/
Untitled Goose Game — https://goose.game/
Stardew Valley — https://www.stardewvalley.net/
Myst — https://cyan.com/games/myst/
Blanco White — https://www.blancowhite.info/
Groundhog Day — https://www.imdb.com/title/tt0107048/
Animal Crossing — https://www.animal-crossing.com/

Special Guest: Johanna Larsson.

Lau Taarnskov on the Trouble with Time Zones

podcast@smartlogic.io (SmartLogic LLC) — Thu, 23 Jul 2020 06:00:00 -0400

Handling date and time is a challenge in any language, but Lau Taarnskov is determined to solve that problem in Elixir. Lau is today’s guest on Elixir Wizards, and this episode is all about his contributions to Elixir. Lau has been involved with web development and e-commerce for decades. He started contributing to Elixir open source in 2014 and created the Calendar and tzdata libraries. Calendar is a datetime library for Elixir, that provides explicit types for datetimes, dates, and times, and full time zone support is provided via its sister package, tzdata. When it comes to the subject of date, time, and time zones, besides talking about it and writing software for it, Lau also writes about it on his blog, Creative Deletion.

This episode explores how Lau got started in programming, and what led him to creating Calendar and tzdata. Lau shares the resources that he found helpful when he started using Elixir, and why he was drawn to Elixir in the first place. We hear Lau’s opinions on time zones and daylight savings and whether or not they’re necessary, and he shares some advice for anyone working with time in Elixir.

Then it’s time for another edition of Pattern Matching with Todd, in which Todd Resudek asks Brooklyn Zekanka five questions to help us get to know her better. Brooklyn talks about everything from she has lived, what jobs she did before becoming a programmer, and her education in classical music, to her favorite bands, movies, and TV shows, as well as some of the projects she is working on. For all this, and more, don’t miss today’s episode!

Key Points From This Episode:

Lau explains what TLAs are and why they aren’t always helpful for explicit communication.
Lau introduces himself and shares how he got into programming and computer science.
The resources Lau found most useful when he started using Elixir, including books he read.
What it means that Elixir’s source code is written in Elixir, and why that was helpful for Lau.
Lu talks about Calendar, a datetime library that Lau created for Elixir, and Tzdata, a parser and library he created for the tz database, and why he created them.
How Lau deconstructed the time zone problems and how his ideas have changed over time.
Lau’s opinions on time zones and daylight savings and whether or not they’re necessary.
Advice from Lau for anyone working with time in Elixir.
Another edition of Pattern Matching with Todd – today’s guest is Brooklyn Zelenka.
Where Brooklyn was born, where she has lived, and the jobs she did before programming.
Brooklyn talks about her musical background and how it’s similar to programming.
Brooklyn shares a pro tip about slides and reflects on her highlights as a speaker.
What Brooklyn would be doing if she weren’t a programmer and the genre of music she likes.
Brooklyn’s favorite TV shows and movies, including Amadeus and Mad Men.
Brooklyn shares what she’s working on currently and the next project she’s excited about.

Links Mentioned in Today’s Episode:

Lau Taarnskov on Twitter – https://twitter.com/laut
Creative Deletion Blog – http://www.creativedeletion.com/
Lau Taarnskov on GitHub – https://github.com/lau
Calendar on GitHub – https://github.com/lau/calendar
Tzdata on GitHub – https://github.com/lau/tzdata
Elixir in Action – https://www.amazon.com/Elixir-Action
Programming Elixir – https://www.amazon.com/Programming-Elixir-1-6-Functional-Concurrent/
Brooklyn Zelenka on LinkedIn – https://www.linkedin.com/in/brooklynzelenka/ Brooklyn Zelenka on
Twitter – https://twitter.com/expede
Brooklyn Zelenka on GitHub – https://github.com/expede
FISSIONcodes Website – https://fission.codes/
SmartLogic — https://smartlogic.io/
Amadeus — https://www.rottentomatoes.com/m/amadeus
Mad Men — https://www.rottentomatoes.com/tv/mad-men

Special Guest: Lau Taarnskov.

Council of Wizards Part 2 with Chris Bell, Desmond Bowe, Emily Maxie, Dan Lindeman, and Alan Voss

podcast@smartlogic.io (SmartLogic LLC) — Thu, 16 Jul 2020 06:00:00 -0400

For part 2 of our Council of Wizards panel discussion, we are joined by Chris Bell, Desmond Bowe, Emily Maxie, Dan Lindeman, and Alan Voss! Chris and Desmond run the ElixirTalk Podcast and we get in-depth on the intersection of the language and talking about it. They share the lessons they have learned in the podcasting space, making some pit stops to chat about aliens, Elixir beef, and marble flooring! We discuss the community during the pandemic and what the Elixir world might look like for the next year or two. Emily and Dan then step in to give us all the information about Very and their very functional remote work model. They talk us through the full departure that the company made from a physical hub and both share what they love and hate about working from home, before and during the COVID crisis. Dan and Emily talk about onboarding and team spirit in remote teams and the strategies that have best served Very in this regard. Lastly, we have a bonus section with Alan Voss, to discuss his game night competitions and more. He unpacks the games he has already hosted and some of the candidates for future events before we hear about his experiences in the pandemic, specifically as an extrovert and a father. For all of this make sure to join us on the show!

Key Points From This Episode:

The exciting possibility of starting beef in the Elixir community!
Books and podcasts we have been reading and listening to.
Marble flooring, glass blowing, aliens, conspiracy theories, and impersonations!
Tips, tricks, and lessons for the podcast space from Chris and Desmond.
Thoughts on the future of the Elixir community during and after the pandemic.
The array of projects that keep Chris and Desmond busy; startups, meetups, conferences!
Very's fully remote-work setup and the decision to move away from a physical office.
Challenges and lessons in the work-from-home model; making do with less in-person interaction.
Positive sides to a home workspace; making a mess and closing the door.
Employee socialization and familiarization at a remote company.
The applicability of Elixir across different projects and libraries.
The infinite amount of puns that are available when talking about Very!
Programming Connect Four and the future of bot competitions according to Alan.
Strategy snobs and taking this to its logical conclusion with chess and Go.
The effect that the pandemic has had on extroverts and the adjustments that Alan has made.
The possibility of ElixirConf this year and the forms it could take.
Work that has gone into Alan's game-night side project over the last months.
The growth of Postmates and their current need for new employees!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Elixir Ecosystem Survey — https://elixirsurvey.typeform.com/to/yYmJv1
ElixirConf — https://elixirconf.com/2020
Github Repo for Transcript Corrections — https://github.com/smartlogic/smartlogic.io/tree/master/podcast/elixir-wizards/transcripts
Chris Bell — https://cjbell.co/
Chris Bell on Twitter — https://twitter.com/cjbell
Desmond Bowe on Twitter — https://twitter.com/desmondmonster
ElixirTalk — http://elixirtalk.com/
Emily Maxie on Twitter — https://twitter.com/emilymaxie
Dan Lindeman on Twitter— https://twitter.com/lindemda
Very — http://verypossible.com/
Chris McCord — http://chrismccord.com/
Alan Voss — http://www.alanvoss.org/
Alan Voss on Twitter — https://twitter.com/alanvoss
Lonestar Elixir— https://lonestarelixir.com/
MPex — https://mpex.com/
Payitoff — https://www.payitoff.io/
Meetup — https://www.meetup.com/
OpenAI — https://openai.com/
Risk — https://www.amazon.com/Hasbro-B7404-Risk-Game/dp/B01ALHAIWG
Strange Loop — https://www.thestrangeloop.com/
Postmates — https://postmates.com/

Special Guests: Alan Voss, Chris Bell, Dan Lindeman, Desmond Bowe, and Emily Maxie.

Council of Wizards Part 1 with Andrea Leopardi and René Föhring

podcast@smartlogic.io (SmartLogic LLC) — Tue, 14 Jul 2020 06:00:00 -0400

The Elixir community continues to flourish and evolve in these uncertain times and in honor of this we have put together a live show with a number of special guests! In part one today, we are joined by Andrea Leopardi and René Föhring, who we are so happy to welcome back. We get the lowdown from each of them in turn, discussing personal preferences, tips and tricks, and recommendations for Elixir and beyond. Andrea gets into some of his pet peeves and comments on the trend of slow interfaces. We then look at future possibilities for Elixir including the outside chance of it being run on mobile and for crypto-mining! Andrea also updates us on the book he is currently working on so keep an eye out for that in the future! René then steps in to talk about his work on Credo, his hopes for it in the future, and some suggestions for listeners using it. We do some comparisons between Elixir and Ruby before René offers some thoughts on Electron and functional programming concepts. So for all this and a whole lot more, make sure to tune in today and stay tuned for part 2!

Key Points From This Episode:

A reintroduction to Andrea and his current work in the Elixir space.
Andrea's tool recommendations and what he uses most at the moment.
Updates, the short term future of the world of Elixir and Andrea's current focus.
RSpec versus xUnit: Andrea's personal preferences.
Andrea's limited experience of LiveView and early reactions.
Feelings about computers and phones with slow interfaces!
The very slim chances of seeing Elixir run on mobile.
Cryptocurrency and Andrea's lack of experience and ambition in the space.
Some exciting information about Andrea's upcoming book to keep an eye out for.
René's current projects; Credo, Elixir weekly newsletter, and more!
The future of Elixir — will it be the next Ruby?
Elixir on a phone; René's thoughts on this possibility and its validity.
Updates for Credo — all the exciting news since our last conversation with René.
Improving work that you are proud of and René's own feelings about Credo.
The objectives and vision for Credo and improving upon certain pain points.
Writing and running in Electron and how to have fun while doing it!
The application of functional programming concepts in René's work in Electron.
René's suggestion for Credo — using the Credo master after it being reworked.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Elixir Ecosystem Survey — https://elixirsurvey.typeform.com/to/yYmJv1
ElixirConf — https://elixirconf.com/2020
Github Repo for Transcripts Corrections - https://github.com/smartlogic/smartlogic.io/tree/master/podcast/elixir-wizards/transcripts
Andrea Leopardi — https://andrealeopardi.com/
Andrew Leopardi on Twitter — https://twitter.com/whatyouhide
Rene Föhring — http://rrrene.org/
Rene Föhring on Twitter — https://twitter.com/rrrene
Alfred — https://www.alfredapp.com/
Tesla — https://www.tesla.com/
TempleOS — https://templeos.org/
Elon Musk — https://www.forbes.com/profile/elon-musk/
Mint — https://www.mint.com/
Finch — https://finch.io/
Ruby — https://www.ruby-lang.org/en/
Electron — https://www.electronjs.org/

Special Guests: Andrea Leopardi and René Föhring.

Chris McCord with a Deep Dive on Phoenix

podcast@smartlogic.io (SmartLogic LLC) — Thu, 09 Jul 2020 06:00:00 -0400

Although it’s taken him four seasons to make an appearance, we are so glad to finally welcome Chris McCord, creator of the Phoenix framework, onto the show. While this season’s focus is on system and application architecture, today’s discussion deviates to focus on Phoenix. We get started by hearing more about Chris’s programming journey, all the way from TI-Basic to where he is now. After this, we dive into LiveView, the project Chris is currently focusing most of his energy on. We get into some of the incredible changes that have been made including live navigation, deep change tracking optimizations, and static asset tracking. Chris shares which of the changes he is most excited about, along with why he enjoys seeing LiveView being misused. We then look at some of the critiques of LiveView and Phoenix generally. Chris offers counter-arguments to the most common criticisms of the framework. He shares how the title of 'framework' can be a double-edged sword, as well as why he is hesitant to extract channels prematurely. We wrap the show up with a look into the future, hearing more about what’s on the horizon for Phoenix and where Chris hopes the Elixir community is headed. This conversation was well worth the four season-long wait, so be sure to tune in today!

Key Points From This Episode:

Why it took Chris four whole seasons to finally make an appearance on the show.
Chris’s programming journey from T-Basic all the way to Java, HTML, and PHP.
How a broken back landed Chris his first paid programming job.
Learn more about Chris’s current project, LiveView, and some of the recent additions.
Why the optimizations were the most interesting changes for Chris to make on LiveView.
Some of the most interesting use cases Chris has seen of LiveView.
How Chris plans to navigate laying LiveView out on a larger codebase.
Chris’s take on stateful applications and why the platform is so important.
The origins of the hilariously termed ‘dead view.’
Some of the most pertinent critiques of LiveView and Phoenix generally.
Chris busts some of the invalid critiques of Phoenix.
Why the community feedback on LiveWire has been so surprising to Chris.
Phoenix 1.6 changes and when we can expect its release.
Chris’s take on whether Elixir is likely to overthrow Rails in terms of popularity.
The systemic blockers that create adoption friction of Elixir and Phoenix.
Looking into the future — Chris’s goals for Phoenix and his hopes for the Elixir community.

Links Mentioned in Today’s Episode:

Chris McCord — http://chrismccord.com/
Chris McCord on Twitter — https://twitter.com/chris_mccord
DockYard — https://dockyard.com/
Dave’s Site — https://www.davesite.com/
Hacking with PHP — http://www.hackingwithphp.com/
Phoenix LiveView — https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
Phoenix Phrenzy — https://groundstation.gigalixirapp.com/
Dashbit: An Upcoming Authentication Solution for Phoenix — https://dashbit.co/blog/a-new-authentication-solution-for-phoenix
Aaron Renner on GitHub — https://github.com/aaronrenner/phx_gen_auth
Phoenix Issues on GitHub —
https://github.com/phoenixframework/phoenix/issuesq=is%3Aopen+is%3Aissue+milestone%3Av2.0
Phoenix Fire Nest — https://github.com/phoenixframework/firenest
Phoenix Pub/Sub — https://github.com/phoenixframework/phoenix_pubsub
ElixirConf 2020— https://2020.elixirconf.com/
ElixirConf 2020 Speaker Proposals — https://2020.elixirconf.com/#cfp
TI-83 Calculator — https://www.amazon.com/Texas-Instruments-TI-83-Graphing-Calculator/dp/B00001N2QU
Teach Yourself C in 21 Days — https://www.amazon.com/Teach-Yourself-21-Days-Sams/dp/0672310694
Rest Fest — https://www.restfest.org/
José Valim on Twitter — https://twitter.com/josevalim
Jason Goldberger on LinkedIn — https://www.linkedin.com/in/jason-goldberger-84237392/
SmartLogic — https://smartlogic.io/
SmartLogic Jobs — https://smartlogic.workable.com/

Special Guest: Chris McCord.

Amos King on MUDs, Architecture, Domain-driven design, and Military Bases

podcast@smartlogic.io (SmartLogic LLC) — Thu, 02 Jul 2020 06:00:00 -0400

Today’s guest is Amos King, Principal CEO at Binary Noggin, and host on the Elixir Outlaws and This Agile Life podcasts. This episode is centered around a casual conversation about everything from programming, the military, sarcasm, and puns to systems and application architecture, domain-driven design, and bitmasks. Amos shares with us how he got into programming, after wanting to be a doctor or an engineer first, and tells us how he met Famous Amos. We talk about spectrum analyzers, Elixir resources, and MUDs, as well as type-first design and Haskell. Amos gives us his takes on domain-driven design, API, booleans, and enums, and even roasts his co-host Chris Keithley a little. Don’t miss this episode for everything you’ve ever wanted to know about the legendary Amos King (and a whole lot more)!

Key Points From This Episode:

Amos explains what Adkron means, which is his gaming and social media handle.
Where the name Elixir Outlaws for the podcast came from.
How Amos got into programming as a career, after wanting to be a surgeon and an engineer.
What Amos’s first opportunity as a programmer was, and how he met Wally Amos.
Amos explains what a spectrum analyzer is, based on his experience in the military.
Amos shares why Steve Bussey’s book, Real-Time Phoenix, is his favorite Elixir resource.
Eric and Amos talk about the MUD engine that they worked on together.
What systems and application architecture means to Amos and how it differs from design.
What type-first design (TFD) is and Amos’s opinion on it as a thought exercise.
Amos talks about Haskell programming and domain-driven design.
Relating domain-driven design to a car dealership to describe types and terminology.
Amos talks a bit about his company and what they do.
Justus, Eric, and Amos debate the term “architect” and what it actually means.
Amos shares his take on API architecture, booleans, enums, and bitmasks.
Amos gives his hot take on his co-host Chris Keithley.

Links Mentioned in Today’s Episode:

Amos King on Twitter — https://twitter.com/adkron
Elixir Outlaws Podcast — https://elixiroutlaws.com/
Wally Amos — https://en.wikipedia.org/wiki/Wally_Amos
Windows 3.0 — https://en.wikipedia.org/wiki/Windows_3.0
Real-Time Phoenix on Pragmatic Bookshelf — https://pragprog.com/book/sbsockets/real-time-phoenix
Elixir School — https://elixirschool.com/en/
Elixir Inaction — https://twitter.com/gausby/status/986550202248187904
This Agile Life Podcast — https://www.thisagilelife.com/
Screen — https://screen.so/#/home
Haskell Book — https://haskellbook.com/
Binary Noggin Website — https://binarynoggin.com/
Binary Noggin on Twitter — https://twitter.com/BinaryNoggin
SmartLogic — https://smartlogic.io/
Justus Eapen on Twitter — https://twitter.com/justuseapen
Eric Oestrich — https://oestrich.org/
Kalevala — https://github.com/oestrich/kalevala
Eric Oestrich on Twitter — https://twitter.com/ericoestrich
Eric Oestrich on GitHub — https://github.com/oestrich

Special Guest: Amos King.

Sundi Myint on The Visual Side of Elixir, the History of Emojis, and Test- and Domain-Driven Architecture

podcast@smartlogic.io (SmartLogic LLC) — Thu, 25 Jun 2020 06:00:00 -0400

Welcome to another episode of Elixir Wizards as we continue our journey into system and application architecture! Our featured guest today is Sundi Myint and she is here to share her journey with Elixir and her non-traditional path to programming. We hear about Sundi's interest in gaming, her role at Cava and a bit of the inspiration behind her amazing Instagram account! We discuss her first internship and how she found herself in the role quite suddenly before diving into the motivation behind her blog post on the history of emojis. Sundi did some serious research into this interesting subject and she shares some of the more technical aspects of the story with us on the show. We talk about architecture and both test and design-driven approaches. Sundi also explains her process and how mapping things out on a whiteboard has been her favored way to do things for some time. Andrea Leopardi then joins us for another edition of Pattern Matching with Todd! He answers Todd's questions about his home life, media favorites, future projects and more!

Key Points From This Episode:

Sundi's Instagram aesthetic and her love of food and photography.
How Sundi got into programming and her first internship.
Getting hired at Cava and an introduction to Elixir and the community.
Video game programming and Sundi's thoughts on the possibility of pursuing this path.
Sundi's first paid job out of college and the tech stack at the company.
Thoughts on easily available learning resources and the power of Live View.
Some background on Sundi's amazing blog post on the history of emojis.
Understanding Unicode, how it works and its role in translation and interpretation.
Sundi's perspectives on architecture and domain-driven design.
Code design strategies, workflow and the idea and practice of test-driven code.
Conversations with stakeholders and moving to the planning stage.
How Sundi uses whiteboards to map out her work graphically and Elixir's part in this.
Andrea's travels and some of the amazing locations he has visited for conferences.
Home life and lifestyle in quarantine for Andrea in Italy.
Alternative career paths and Andrea's other interests; balancing creativity and logic.
Music, movies and television choices for Andrea.
Exciting new projects on the horizon for Andrea; a book, HTTP and more!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Sundi Myint on Twitter — https://twitter.com/sundikhin
Sundi Myint on Instagram — https://www.instagram.com/sundikhin
Cava — https://cava.com/
Hackers & Painters — https://www.amazon.com/Hackers-Painters-Big-Ideas-Computer/dp/1449389554
Lonestar Elixir — https://lonestarelixir.com/
Bruce Tate — https://codesync.global/speaker/bruce-tate/
EA — https://www.ea.com
Groxio Learning — https://grox.io/training/elixir/home
Live View — https://support.google.com/maps/thread/11554255?hl=en
Build a real-time Twitter clone in 15 minutes with LiveView and Phoenix 1.5 — https://www.youtube.com/watch?v=MZvmYaFkNJI
The History of Emojis Blog Post — https://engineering.upside.com/emojis-a-history-75d595bbe4a5?gi=6cd53698e5d
Burgergate https://www.theverge.com/2017/10/30/16569346/burgergate-emoji-google-apple
Joy of Coding — https://joyofcoding.org/
Test-driven development — https://en.wikipedia.org/wiki/Test-driven_development
Mox — https://hexdocs.pm/mox/Mox.html
Venmo — https://venmo.com/
Mint — https://www.mint.com/
Avengers — https://www.marvel.com/movies/avengers-endgame
DC Elixir — https://www.meetup.com/DC-Elixir/
Todd Resudek — https://medium.com/@toddresudek
Andrea Leopardi — https://andrealeopardi.com/
Brooklyn Zelenka — https://medium.com/@expede
The Lord of Rings — https://www.rottentomatoes.com/franchise/lord_of_the_rings
Wes Anderson — https://www.imdb.com/name/nm0027572/
Scott Pilgrim vs. The World — https://www.rottentomatoes.com/m/scott_pilgrims_vs_the_world
Community — https://www.rottentomatoes.com/tv/community
The Office — https://www.rottentomatoes.com/tv/the_office
Rick and Morty — https://www.rottentomatoes.com/tv/rick_and_morty
Justus Eapen on Twitter — https://twitter.com/justuseapen
Eric Oestrich on Twitter — https://twitter.com/ericoestrich

Special Guests: Andrea Leopardi and Sundi Myint.

Dave Thomas on Learning How Things Work

podcast@smartlogic.io (SmartLogic LLC) — Thu, 18 Jun 2020 06:00:00 -0400

Dave Thomas is recognized internationally as an expert who develops high-quality software–accurate and highly flexible systems. He helped write the now-famous Agile Manifesto, and regularly gives inspiring and controversial speeches on new ways of producing software. He is the author of six books, including the best selling The Pragmatic Programmer: From Journeyman to Master and Programming Ruby: A Pragmatic Programmer's Guide. In this episode, we discuss everything from learning computer science in an academic setting, test-driven development, and state to architecture, libraries, and what Dave loves about what he does. Dave talks about his students, both those who are passionate and those who are just going through the motions, as well as his own experience of being a student. He explains to us what he means when he said he doesn’t write unit tests at an Elixir conference in Austin recently, we talk about his favorite and most rewarding books, and Dave gives us a really unique answer to our architecture question. We discuss domain-driven design, microservice architectures, and Elixir libraries, and Dave shares why is so passionate about what he does. Tune in to hear some of Dave’s strong opinions on programming!

Key Points From This Episode:

The Coding Gnome and how it bridges the gap between learned and practical experience.
Dave talks about being a lecturer at SMU and why students aren’t prepared for the real world.
Why Dave stopped teaching Elixir at SMU.
Students who study computer science for passion versus those who study it to get a job.
Dave talks about his experience of studying computer science at university.
The inspiring and controversial keynote addresses Dave has given at conferences.
What it means when Dave said he doesn’t write unit tests and the projects he’s working on.
The culture around test-driven development and writing tests when Dave was at university.
Dave tells a story about writing the incoming telex switch for the UK.
Why the first edition of Programming Ruby was Dave’s favorite book to write.
Why The Pragmatic Programmer is the book Dave is most proud of.
Dave isn’t currently writing a new book, so he can concentrate on pseudo-course material.
Dave explains the process of developing a narrative arc when writing a technical book.
What the state of a system is and how it is distinct from data.
Dave describes why he believes architecture is a misunderstood and borrowed metaphor.
Dave’s opinions on buzzwords like domain-driven design and microservice architectures.
The status on The Component Library, as mentioned by Dave in his EMPEX 2018 keynote.
Getting involved with publishing Elixir libraries and what his process looks like.
How Dave likes to receive product specification when dealing with clients.
What Dave loves about the programming industry.
Why Dave doesn’t write Elixir anymore and why he became frustrated with it.
Where Dave is going from here to how best to express what he wants.
Final advice from Dave, not to abandon Elixir if it makes you happy.

Links Mentioned in Today’s Episode:

Dave Thomas on Twitter – https://twitter.com/pragdave
The Coding Gnome – https://pragdave.me/
The Coding Gnome Training — https://codestool.coding-gnome.com/
Agile Manifesto – https://agilemanifesto.org/
The Pragmatic Programmer – https://pragprog.com/book/tpp20/the-pragmatic-programmer-20th-anniversary-edition
Programming Ruby – https://en.wikipedia.org/wiki/Programming_Ruby
Robert Kowalski on Wikipedia — https://en.wikipedia.org/wiki/Robert_Kowalski
Dave Thomas on Wikipedia — https://en.wikipedia.org/wiki/Dave_Thomas_(programmer)
Space-state representation — https://en.wikipedia.org/wiki/State-space_representation
Christopher Alexander — https://en.wikipedia.org/wiki/Christopher_Alexander
A Pattern Language — https://en.wikipedia.org/wiki/A_Pattern_Language
Dave Thomas Keynote at Empex NYC 2018 — https://www.youtube.com/watch?v=6U7cLUygMeI
SmartLogic — https://smartlogic.io/
Justus Eapen on Twitter — https://twitter.com/justuseapen
Eric Oestrich on Twitter — https://twitter.com/ericoestrich

Special Guest: Dave Thomas.

Ben Marx on the Launch and Architecture of SubSpace

podcast@smartlogic.io (SmartLogic LLC) — Thu, 11 Jun 2020 06:00:00 -0400

Joining us on the show for this episode is Ben Marx, author of Adopting Elixir and Principal Control Plane Engineer at the recently launched SubSpace! We continue our Season 4 journey into system and application architecture with Ben and he unpacks what he can about the somewhat still under wraps work at the new company. Ben is all about plain-spoken and easy to understand conversations on these topics, preferring to avoid highfalutin and confusing terms with multiple interpretations. He really drills down on his understanding of the fundamentals of his work and we also get to hear about his previous position at Bleacher Report. He unpacks the lessons he took away from the company, and the changes he witnessed while there. Ben explains how Elixir fits into the work at SubSpace and what a perfect fit it is for their low-latency service. We also spend a bit of time talking about life as an introverted programmer, attending conferences and meeting people, and remote work and family life during the pandemic. For all this and then some, tune in today!

Key Points From This Episode:

Ben's exciting new position at SubSpace, and how the company reduces latency.
The increasing need for more reliable internet speeds during the pandemic.
Use of Elixir for SubSpace and how well it fits the needs of the company.
The engineering team at SubSpace and some of the basic system architecture.
Meeting people, giving talks and life at conferences as an introvert.
The meaning of architecture to Ben; more dynamic than static.
Differentiating between architecture and design; the abstract and reality.
The idea of domain-driven design what the concept means to Ben.
Placement of the authentication and authorization systems.
Ben's time working at Bleacher Report and the development of the company during his time there.
Thoughts on Kafka and its baffling name!
Ben's new role at SubSpace and major areas of learning for him so far.
Adapting to a new role during the work from home era; life under quarantine.
Project management and helpful processes for remote work in a new world.
Ideas for another book from Ben, his belief in Elixir and getting in contact!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Ben Marx — https://bgmarx.com/
SubSpace — https://www.subspace.com/
Ben Marx on Twitter — https://twitter.com/bgmarx
Adopting Elixir — https://www.amazon.com/Adopting-Elixir-Production-Ben-Marx/dp/1680502522
Bleacher Report — https://bleacherreport.com/
Subspace article at the Wall Street Journal — https://www.wsj.com/articles/subspace-launches-publicly-offering-fast-internet-for-gaming-companies-11584961201
Subspace article at VentureBeat — https://venturebeat.com/2020/04/03/the-deanbeat-subspace-emerges-from-stealth-with-26-million-to-fix-internet-bottlenecks-for-games-and-entertainment/
Kafka — https://kafka.apache.org/coding-guide
Franz Kafka — https://www.biography.com/writer/franz-kafka
Max Brod — https://www.britannica.com/biography/Max-Brod
Sophie DeBenedetto — http://sophiedebenedetto.nyc/
Justus Eapen on Twitter — https://twitter.com/justuseapen
Eric Oestrich — https://oestrich.org/
Eric Oestrich on Twitter — https://twitter.com/ericoestrich
Eric Oestrich on GitHub — https://github.com/oestrich

Special Guest: Ben Marx.

Pattern Matching - Johanna Larsson

podcast@smartlogic.io (SmartLogic LLC) — Tue, 09 Jun 2020 06:00:00 -0400

A special episode of Elixir Wizards highlighting Pattern Matching with Todd - a short format interview where our friend, Todd Resudek, asks different guests the same five questions. This week Todd spoke with Johanna Larsson. Johanna is active on the Elixir scene and is currently working as a Software Engineer at Duffel.

Key Points From This Episode:

Living in Malmo, Sweden.
Johanna's love of languages.
The complexities of written Japanese.
How Johanna uses music to set the soundtrack to her work.
Todd missing the boat on a cinematic and cultural masterpiece.
Integrating and improving upon the hex diff project.

Links Mentioned in Today’s Episode:

Johanna Larsson on GitHub - https://github.com/joladev
Johanna Larsson on Twitter - https://twitter.com/joladev
Todd Resudek on Twitter — https://twitter.com/sprsmpl
SmartLogic — https://smartlogic.io/

Special Guest: Johanna Larsson.

Steve Bussey on Real-Time Applications

podcast@smartlogic.io (SmartLogic LLC) — Thu, 28 May 2020 06:00:00 -0400

Real-time applications come with real challenges—persistent connections, multi-server deployment, and strict performance requirements are just a few. Our guest today is Steve Bussey, a software architect at SalesLoft and author of the new book, Real-Time Phoenix: Build Highly Scalable Systems with Channels. In this episode, Steve shares with us what he has written on real-time Elixir applications and how he has led development in the field. We discuss how Steve found Elixir, what system and application architecture means to him, and what he considers the differences between architecting and designing a system. Steve gives us his opinions on domain-driven design, umbrella apps, and Phoenix LiveView, and shares some of his personal processes when working on new real-time features, as well as what he believes are the toughest parts of developing and rolling out real-time applications. Finally, we talk about testing, security, and performance issues, and Steve sells us on his book. Tune in today!

Key Points From This Episode:

What Steve’s favorite pair of shoes is and how he got into sneakers.
Where Steve is from and how long he has been doing programming.
What system and application architecture means to Steve.
The difference between architecting and designing a system.
Steve’s opinions on domain-driven design.
Eric’s opinion on umbrella apps and Steve’s response.
Where Steve starts when he works on a new real-time feature.
Steve’s personal and professional pre-code design processes.
The toughest parts of developing and rolling out real-time applications.
Testing real-time features and Steve’s thoughts on Phoenix LiveView.
How Steve incorporates security into the architecture when designing applications.
Multi-tenant applications and how Steve deals with performance issues.
Deployment considerations when going into production with a real-time application.
Steve sells us on his book and gives his final plugs and asks for the audience.

Links Mentioned in Today’s Episode:

Steve Bussey on Twitter – https://twitter.com/YOOOODAAAA
Steven Bussey’s Website – https://stevenbussey.com/
Real-Time Phoenix on Pragmatic Bookshelf – https://pragprog.com/book/sbsockets/real-time-phoenix
SmartLogic — https://smartlogic.io/
Justus Eapen on Twitter — https://twitter.com/justuseapen
Eric Oestrich — https://oestrich.org/
Eric Oestrich on Twitter — https://twitter.com/ericoestrich
Eric Oestrich on GitHub — https://github.com/oestrich

Special Guest: Steve Bussey.

Mohd Maqbool Alam on System and Application Architecture

podcast@smartlogic.io (SmartLogic LLC) — Thu, 21 May 2020 06:00:00 -0400

Today’s guest is Mohd Maqbool Alam, a software developer and Elixir fan from Delhi. He enjoys learning about programming language theory, distributed systems, Cloud Native technologies, and open source. As he is working towards building an Elixir community in Delhi, we caught up with him to find out how he came to be part of the Elixir world, and what drew him to programming in the first place. We also discuss Maqbool’s favorite Elixir resources and how Elixir has changed the way he thinks about architecture applications, as well as his opinions on microservices, APIs, and static typing. We talk about the real-world consequences of programming, using Neil Ferguson’s pandemic simulation model as an example, and Maqbool shares his favorite RPC (when we actually meant to ask him his favorite RFC)! The episode concludes with Pattern Matching with Todd. In this edition, he discusses Kubernetes and Beam with Principal Software Architect Cory O’Daniel.

Key Points From This Episode:

Maqbool tells us a bit about himself and how he came to be part of the Elixir community.
What enticed Maqbool to programming.
Maqbool’s favorite resources from Elixir.
How Elixir has changed the way Maqbool thinks about architecting applications.
Maqbool’s ‘aha’ moment in distributed programming and how he got into pattern matching.
Phoenix Live Dashboard and why Maqbool and the team are excited about it.
How Maqbool approaches the design process when building an application from scratch.
The tools and methods Maqbool uses when designing information architecture and APIs.
Maqbool’s opinions on microservices, Kubernetes, and Amazon Lambda.
Protocols and non-standard protocols.
Neil Ferguson’s pandemic simulation model using undocumented C-code.
How we should think about the real world consequences of high-stakes programming.
Maqbool’s opinion on static typing.
Macbool’s favorite RPC and RFC.
Pattern Matching with Todd Resudek, discussing Kubernetes and Beam with Cory O’Daniel.

Links Mentioned in Today’s Episode:

Justus Eapen on LinkedIn — https://www.linkedin.com/in/justuseapen/
Justus Eapen on Twitter — https://twitter.com/justuseapen
Eric Oestrich — https://oestrich.org/
Eric Oestrich on Twitter — https://twitter.com/ericoestrich
Eric Oestrich on GitHub — https://github.com/oestrich
Mohd Maqbool Alam on Twitter – https://twitter.com/Maqboolism
Elixir Forum – https://elixirforum.com/
Elixir in Action – https://www.amazon.com/Elixir-Action-Sa%C5%A1a-Juri-cacute/dp/161729201X
Phoenix Live Dashboard – https://github.com/phoenixframework/phoenix_live_dashboard
Absinthe – https://github.com/absinthe-graphql/absinthe
Kubeless – https://kubeless.io/
Kubernetes — https://kubernetes.io/
Amazon Lambda – https://aws.amazon.com/lambda/
Groxio – https://grox.io/
Todd Resudek on Twitter — https://twitter.com/sprsmpl
Cory O’Daniel on Twitter – https://twitter.com/coryodaniel
Ziggy O’Doodle on Instagram – https://www.instagram.com/ziggy.odoodle/
SmartLogic — https://smartlogic.io/

Special Guests: Cory O'Daniel and Mohd Maqbool Alam.

Season Four Launchisode

podcast@smartlogic.io (SmartLogic LLC) — Thu, 14 May 2020 06:00:00 -0400

As our first trilogy comes to a close, and we embark on the next one, we’re doing what all great trilogies do: Upending everything that made the initial one great and starting afresh. We have taken on board some excellent listener feedback to keep this the highest quality Elixir related podcast. So, for this launchisode, rather than doing a trailer, we are diving in headfirst with a full episode on system and application architecture, this season’s theme, with Justus Eapen, Dan Ivovich, and Eric Oestrich.

We kick off the show by getting to know Dan and Eric a bit better. This season, as per listener requests, we will spend more time on our guests' personal lives. We learn about Dan and Eric’s time at SmartLogic, their experience working with Elixir, and their approaches to learning it. From there, we move onto tackling clients’ projects. We discuss the importance of letting ideas flow free as well as how to break projects down into manageable sized segments to work on. Following this, we touch on flexible architecture. As the world changes, sometimes at a pace faster than we anticipate, it is more important than ever to design systems that we can iterate on. Then, we discuss the future of applications and architecture and the exciting possibilities in-store.

The show rounds off with our new segment, Pattern Matching with Todd, where our friend Todd Resudek gets to know someone in the community a bit better. Today, he talks with Connor Rigby of Binary Noggin, finding out more about his programing journey, his favorite music and movies, and his WiFi meshing project. We're so excited for this season, and we hope you join us on the journey. Tune in today!

Key Points From This Episode:

Dan’s background and how he came to be Director of Development Operations.
How Eric started at SmartLogic and what his journey at the company has been like.
Learn what convinced Dan to go all-in on Elixir and make the move from Rails
Some of the educational materials and tools Dan and Eric used to learn Elixir.
Dan’s preferred style of design and why he enjoys TDD.
Why we think that Cucumber falls short and chose to move away from it.
Find out what we think domain-driven design is.
How Dan and Eric approach deconstructing clients’ projects.
Pre-coding: Why it’s best to do free-form planning, with no constraints.
Insights into the broad-reaching term of ‘API’ and what we mean by it.
SOAP and REST APIs: What they are and the differences between them.
How Dan, Eric, and Justus’s thinking about designing and application architecture has evolved.
Object-oriented programming versus functional: Our take on the age-old debate.
Is this finally the year that we get to kill micro-services?
The relationship between team size and micro-services and some other constraints.
What the future has in store for applications and architecting.
Pattern-matching with Todd: Five questions to get to know Connor Rigby a bit better.

Links Mentioned in Today’s Episode:

Special Guests: Connor Rigby and Dan Ivovich.

Betweenisode Part 2! Featuring Amos King, Chris Keathley, Anna Neyzberg, Paul Schoenfelder, Sophie DeBenedetto, Meryl Dakin, and Dave Thomas

podcast@smartlogic.io (SmartLogic LLC) — Thu, 23 Apr 2020 06:00:00 -0400

Welcome back to part two of our betweenisode! Everybody is working remotely now including ourselves, so today we continue the catch ups we were having with a number of longstanding buddies and chat about life after social distancing! The show is a back-to-back of four different conversations, the first being with Amos King, Chris Keathley, and Anna Neyzberg from Elixir Outlaws. After that we talk to Paul Schoenfelder, before getting on the line with Sophie DeBenedetto and Meryl Dakin. Last but not least we catch up with Dave Thomas. Our four conversations cover the same broad themes, and we mostly share our thoughts about what is happening in the world right now, how we are coping with working remotely, and what particular projects have been keeping us busy. Our guests share varying perspectives about what it means that we are restructuring the way we do things. We talk about how even if you worked remotely before, things feel different now, and we also consider the extra burdens of being a remote software developer. Other topics include the line between complaints and constructive criticism, wild animals roaming the streets, and the general atmosphere in our different locations. From a tech point of view, we touch on IoT development, various GitHub projects to get involved with, why students aren’t learning how to program properly anymore, and a lot more. Get it all here and make sure you stay tuned for episode one of season four!

Key Points From This Episode:

Scaling up the NFL Draft website for remote screening.
Home life and side projects in the quarantine: Mogde Podge, a baby, and game development.
Shameless plugs from everybody: Binary Noggin, ElixirBridge, and Finch.
Isolation, low supplies and trying to stay positive at present.
Imagining roaming wild animals now that humans are in quarantine.
Advice from Paul who works at home for surviving social distancing.
What Paul is doing for Ockam to secure IoT devices.
The danger of starting hack vulnerable tech companies.
A plug from Paul to get involved with Lumen.
Nature taking over; Meryl and Sophie’s experiences in Brooklyn and Westchester right now.
Working from home versus working from home due to a global crisis.
Domestic squabbles over bandwidth between Meryl and her software developer brother.
Lessons learned to stay sane during quarantine: getting dressed.
Extra tasks remote developers are having to do remotely; becoming project managers.
The difference between complaints and legitimate critiques of work systems.
Dave’s amazing remote communications setup 40 miles north of Dallas.
The situation where Dave is with regard to coronavirus and freedom.
How COBOL has not become too broad despite not using libraries.
The history of programming languages that Dave teaches.
That PDP-11 runs better emulated in Javascript than in its original hardware.
A drawback of modern development: not understanding hardware.
How Dave is digitizing his SMU courses due to teaching them online at present.
All the effort Dave puts into grading his students’ exercises.
Issues that coding is not taught rigorously enough; students can’t ‘program’.
How well the human race is doing to mobilize en masse right now.
Whether tech caused the crisis and humanity could manage this crisis 100 years ago.

Links Mentioned in Today’s Episode:

Eric Oestrich — https://oestrich.org/
Justus Eapen — https://www.linkedin.com/in/justuseapen/
Amos King — https://www.linkedin.com/in/amosking/
Chris Keathley — https://keathley.io/
Anna Neyzberg — https://www.linkedin.com/in/anna-neyzberg-93545316/
Elixir Outlaws — https://elixiroutlaws.com/
NFL Draft — https://www.nfl.com/draft/home
Modge Podge — https://www.amazon.com/Mod-Podge-Waterbase-16-Ounce-CS11302/dp/B001IKES5O
Star Trek — https://intl.startrek.com/
Sublime — https://www.sublimetext.com/
VSCode — https://code.visualstudio.com/
Binary Noggin — https://binarynoggin.com/
Connor Rigby — https://binarynoggin.com/author/connor/
ElixirBridge — http://elixirbridge.org/
Nico Piderman — https://github.com/sneako
Quinn Wilton — https://github.com/QuinnWilton
Jose Valim — https://github.com/josevalim
Finch Library— https://github.com/keathley/finch
Paul Schoenfelder — https://www.linkedin.com/in/gotbones/
Ockam — https://www.ockam.io/
Lumen — https://github.com/lumen/lumen
Timex — https://github.com/bitwalker/timex
Sophie DeBenedetto — https://www.linkedin.com/in/sophiedebenedetto/
Meryl Dakin — https://github.com/meryldakin
Flatiron — https://flatironschool.com/
Sophie DeBenedetto’s GitHub Post — https://www.thegreatcodeadventure.com/my-long-distance-relationship-with-github/
Elixir School — https://elixirschool.com/en/
Meryl Dakin’s Watch if Your Dare Episode — https://www.stitcher.com/podcast/watch-if-you-dare/e/68798094?autoplay=true
Luigi’s Mansion — https://www.nintendo.co.za/Games/Nintendo-Switch/Luigi-s-Mansion-3-1437312.html
Dave Thomas — https://pragdave.me/
COBOL — https://www.tutorialspoint.com/cobol/index.htm
PD-11 — https://history-computer.com/ModernComputer/Electronic/PDP-11.html
SMU — https://www.smu.edu/lyle
Elixir Wizards Podcast — https://podcast.smartlogic.io
SmartLogic — https://smartlogic.io/

Special Guests: Amos King, Anna Neyzberg, Chris Keathley, Dave Thomas, Meryl Dakin, Paul Schoenfelder, and Sophie DeBenedetto.

Betweenisode Part 1: Saša Jurić, Bruce and Maggie Tate, James Edward Gray II, Jim and Chris Freeze, and Frank Hunleth

podcast@smartlogic.io (SmartLogic LLC) — Tue, 21 Apr 2020 06:00:00 -0400

The world has changed so much since the end of season 3, that we thought we’d put together a special Betweenisode to tide you over until Season 4 launches. In this episode, we talk to several friends and respected members of the Elixir community, about how they’re coping and tips they have for retaining some normalcy in your life if you’re suddenly having to work from home. Our first guest, Saša Jurić, of Very Big Things, and author of the unrivaled Elixir in Action, has had the privilege of working from home for several years. He shares the importance of having a routine, connecting with people, and why you should get out of your pajamas and into some real clothes when you work. He also shares what it’s been like in his home city of Zagreb, and how previous devastating events have in some way prepared him for what’s currently happening. Bruce and Maggie Tate of Groxio, an educational platform to learn languages, also join us. Maggie shares more on her culinary adventures, and the importance of having a definite start and finish time to your day. Bruce talks about some of the professional projects he’s working on, and why he believes it’s crucial to tackle difficult technical skills outside of developing. Other guests include James Edward Gray II, who shares more about the incredible way he and his daughter have been bonding, Jim Freeze, founder of ElixirConf, and his son Chris, who share some of the benefits of working from home, and show us how to see the silver lining during this difficult time, and Frank Hunleth, of Nerves Project, who talks about what he’s up to. There have certainly been more changes in the world than we could have anticipated, so it was wonderful to catch up and see how people in our community have been coping. Be sure to tune in today!

Key Points From This Episode:

Learn what’s happening in Saša’s home city, Zagreb, and what he’s doing to keep busy.
Saša’s advice for coping during the pandemic and preventing information overload.
The transition to remote work in Saša’s company and the impacts it’s had on workload.
How Saša started working remotely and the main lessons he has learned from doing it.
What Saša believes the future of virtual events and conferences will be.
Find out how Bruce and Maggie are dealing with these strange times.
Groxio’s mission in terms of learning and Bruce and Maggie’s tip for working from home.
Current projects that Bruce and Maggie are working on both at Groxio and personally.
What’s in the pipeline with Groxio’s Elixir material and Bruce and Maggie’s plugs.
How James is holding up and his take on the COBOL debacle.
Find out what motivated James to transition from Ruby to Elixir and what it’s been like.
James’s experience working from home and tips for people who are new to it.
Specific versus general solutions: The difference and how James thinks we can tackle this.
Hear James’s ExVenture plug, which is Eric’s project.
Jim’s and Chris’s experience of the lockdown and the silver linings that have come from it
Find out Jim and Chris’s necessities for working from home and being productive.
Jim’s plans for ElixirConf for this year and 2021, and Chris and Jim’s final plug.
Frank’s tips for working from home and his product plugs.

Links Mentioned in Today’s Episode:

Saša Jurić on Twitter — https://twitter.com/sasajuric
Saša Jurić on LinkedIn — https://hr.linkedin.com/in/sa%C5%A1a-juri%C4%87-21b23186
Erlangelist — https://www.theerlangelist.com/
Very Big Things — https://verybigthings.com/
Elixir in Action — https://www.manning.com/books/elixir-in-action-second-edition
Bruce Tate — https://www.linkedin.com/in/bruce-tate-a836b
Bruce Tate on Twitter — https://twitter.com/redrapids
Maggie Tate on LinkedIn — https://www.linkedin.com/in/maggie-tate-230234171
Groxio — https://grox.io/
Programmer Passport — https://elixirforum.com/t/programmer-passport-grox-io-pragprog/28253
Lonestar Elixir — https://lonestarelixir.com/
James Edward Gray II — https://twitter.com/JEG2
COBOL — https://www.tutorialspoint.com/cobol/index.htm
Gray Inc — http://graysoftinc.com/
Programming Erlang — https://pragprog.com/book/jaerlang2/programming-erlang
Nathan Long — https://twitter.com/sleeplessgeek
POV-Ray — http://www.povray.org/
Elixir Wizards S02 Eric on ExVenture — https://podcast.smartlogic.io/season-two-oestrich
Jesse Link — http://www.jesselink.com/
Jim Freeze on Twitter— https://twitter.com/jimfreeze
ElixirConf — https://elixirconf.com/2020
Chris Freeze on Twitter— https://twitter.com/chrisfreeze_
Tesla Car Lot — https://teslacarlot.com/
David Antaramian — https://www.linkedin.com/in/davidantaramian/
PepsiCo — https://www.pepsico.com/
Nerves Project — https://www.nerves-project.org/
Frank Hunleth on Twitter — https://twitter.com/fhunleth
SmartLogic — https://smartlogic.io/

Special Guests: Bruce Tate, Chris Freeze, Dr. Jim Freeze, Frank Hunleth, James Gray, Maggie Tate, and Saša Jurić.

Season Three Wrap and Remote Work Tips

podcast@smartlogic.io (SmartLogic LLC) — Thu, 02 Apr 2020 06:00:00 -0400

In this episode, we take a look into the current contexts and home lives many of us find ourselves in today, offering top tips for working remotely from home during these challenging times. The lockdowns have caused many of us to reflect. To reflect on our lives, our work, what we’re grateful for, and in this case, our epic last season of Elixir Wizards! Here, we take you through the highlights, the lowlights, our biggest lessons, our juiciest debates, and what you can expect for Season 4 – in sickness and in health. Stay safe, listen, and enjoy!

Key Points from This Episode:

The importance of demarcating your workspace, especially when the kids are home!
Always put your pants on: Why sticking to your morning schedule helps productivity.
Ways to eliminate the potential for distraction when working from home.
How working from home is enabling programmers to see one another’s human side.
Taking a break from conferences, cognition, and learning how to birth a baby Oestrich.
Third dimensions and entering the tangential learning plane with Brooklyn Zelenka.
The Surprise Toddcast: Why the improvised episode was a hit.
What it was like interviewing entrepreneurial couple, Bruce & Maggie Tate.
Remember the time the father and son roasted each other on the podcast mic?
Why your podcast audience wants to know your guests on a more personal level.
A recap of the numbers from Season 1-3 and the 40,000+ Elixir Wizards downloads.
A sneak peek into the new Elixir Wizards theme for the upcoming Season 4.
Lib versus Web and other essential tips for the lazy Phoenix users out there.
Why we need a whole season on application architecture and one-letter module names.
The debate sparked by the disagreement between Chris Keathley and Brooklyn Zelenka.
Hackers, painters, Paul Graham, and the argument made in favor of dynamic typing.
Find out more about Sophie and Meryl’s epic takeover of Elixir Wizards!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Eric Oestrich — https://twitter.com/ericoestrich?lang=en
Justus Eapen — https://twitter.com/justuseapen
Brooklyn Zelenka on Witchcraft — https://podcast.smartlogic.io/season-two-zelenka
Brooklyn Zelenka — https://twitter.com/expede?lang=en
Bruce and Maggie Tate from Groxio on Training — https://podcast.smartlogic.io/s3e8-groxio
Saša Jurić — https://twitter.com/sasajuric
Bonus Toddcast & Lonestar Preview — https://podcast.smartlogic.io/s3e14-bonus-toddcast-and-lonestar-preview
The Lonestar Lunchisode — https://podcast.smartlogic.io/s3-lonestar-lunchisode-2020
Dave Thomas — https://www.davethomas.net/talks_index.html
Bonus Episode: Outlaws and The Wizards — https://podcast.smartlogic.io/s3-bonus-outlaws-and-wizards
Chris Keathley — https://twitter.com/ChrisKeathley
Paul Graham — http://www.paulgraham.com/
Sean Lewis from Divvy on Performance, Hiring and Training — https://podcast.smartlogic.io/s3e12-divvy
Devin C. Estes — https://twitter.com/devoncestes?lang=en
Muzak — https://www.kickstarter.com/projects/devonestes/muzak-a-mutation-testing-library-for-elixir-and-erlang

Special Guest: Todd Resudek.

Sophie and Meryl Takeover: Sean Callan and Steven Nunez on Elixir Education

podcast@smartlogic.io (SmartLogic LLC) — Thu, 26 Mar 2020 06:00:00 -0400

Welcome to another extra special episode of Elixir Wizards! We have guest hosts today, Meryl Dakin of Frame.io and Sophie DeBenedetto of Github, and they welcome Steven Nunez, Staff Engineer at the Flatiron School, and Sean Callan, creator of Elixir School, to the show. Where some would see the fact that Elixir doesn’t have a ton of readily available answers out there as a restriction to mastering the language, our guests argue that this is the best educational environment. Writing about challenges and teaching others how you overcame them are some of the best ways to learn. We also discuss concurrency and other contrasts with prominent languages. Our guests weigh in on dealing with students and how far enthusiasm and openness can go in helping inspire other minds. Steven stresses the need for greater resources, especially at a beginner level, as this will lower the barrier to entry for new programmers and ultimately benefit the entire Elixir community.

Key Points From This Episode:

An introduction to Sean and Steven, their work and experience with Elixir.
Work and professional horoscopes for the panel of today's podcast!
The accidental path that led Sean to Elixir and the translations that affirmed his work.
The use of writing and blogging in your own education; teaching is learning twice!
Steven's early attraction to Elixir and the obsession and evangelism that followed.
Concurrency visibility and differences between Elixir and other languages.
Different tracks for learning; coming into Elixir as a beginner or as someone with experience.
The evolution of thought around education and things that have changed at Elixir School.
Learning that includes reasons why; you don't know what you don't know!
Knowing your students and keeping them excited to maintain a passion for learning.
Growing confidence and the benefits of great resources for the spread of increasing skills.
Scratching your own itch; write the educational information that you cannot find yourself.
Our guest's Elixir wish lists; more learning opportunities, widespread adoption and beginner-friendly content.
Requests about Elixir from our guests, a few plugs and how to connect with them!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Sophie DeBenedetto — https://twitter.com/sm_debenedetto
Meryl Dakin — https://twitter.com/meryldakin
Steven Nunez — https://twitter.com/_stevennunez
Sean Callan — https://twitter.com/doomspork
System 76 — https://system76.com/
Flatiron — https://flatironschool.com/
Elixir School — https://elixirschool.com
GitHub — https://github.com/
Erlang — https://www.erlang.org/
Phoenix — https://www.phoenixframework.org/
Kubernetes — https://kubernetes.io/
The Developer's Guide to Content Creation — https://www.developersguidetocontent.com/
Stephanie Morillo — https://www.stephaniemorillo.co/
Elixir and The Beam: How Concurrency Really Works https://www.thegreatcodeadventure.com/elixir-and-the-beam-how-concurrency-really-works/

Special Guests: Sean Callan and Steven Nunez.

Saša Jurić on Training

podcast@smartlogic.io (SmartLogic LLC) — Thu, 19 Mar 2020 06:00:00 -0400

Saša Jurić is a household name in the Elixir and Erlang space and we are so glad to finally welcome him on to the show today! Author of Elixir in Action, Saša is here to discuss training and his thoughts on getting a team up to speed with regards to testing and beyond. We hear from our guest about his discovery of Elixir, his uncharacteristic early adoption of the language, and why he chose it. From there, Saša talks a bit about his book, the opportunity that arose for him to write it after Manning approached him and how he views its place among other prominent pieces of literature on the subject. We discuss early steps in the process of learning Elixir for new programmers and old, and Saša weighs in on when it might be a good idea to put in the effort. We also get to hear about very big things, where Saša works and the central work and services of the agency. The last part of our conversation is spent on more technical aspects of Saša's work, his approach to coding in general and then approaches to testing and the training side of this. Join us today for this great conversation!

Key Points From This Episode:

Saša's discovery of Elixir and his first experiences of the language.
A lucky opportunity to write a book that presented itself to Saša!
The complementary nature of Elixir in Action; reading it in conjunction with other books.
Ideas on how to introduce the concepts of Elixir to new programmers and the unfamiliar.
The effort needed in order to understand and adopt the new paradigm of Elixir.
Saša's work at very big things and the services that the agency offers.
The most useful idioms that Saša uses and the modes of operation at that agency.
Saša's use of Dialyzer for debugging despite its imperfections.
The exploratory nature of good coding and finding solutions as you go.
Helper libraries and comparing functions from Saša's own one!
Training for unit, feature and integration testing; Saša's approach for his team.
Differentiating between the different types of testing and the importance of naming.
Clarifying Saša's philosophy on testing and his understanding of the term 'unit'.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Saša Jurić on Twitter — https://twitter.com/sasajuric
The Erlangerist — https://www.theerlangelist.com/
Elixir in Action — https://www.manning.com/books/elixir-in-action-second-edition?query=sa%C5%A1a - use special code podexwizards20 for 40% off your purchase at Manning Publications!
Michael Stevens — https://www.linkedin.com/in/michaelstephens2
Manning — https://www.manning.com/
Programming Elixir — https://pragprog.com/book/elixir16/programming-elixir-1-6
Learn Functional Programming with Elixir — https://pragprog.com/book/cdc-elixir/learn-functional-programming-with-elixir
very big things — https://verybigthings.com/
Dialyzer — https://hexdocs.pm/dialyzex/Mix.Tasks.Dialyzer.html
Hackers & Painters — http://shop.oreilly.com/product/9780596006624.do
Paul Graham — http://www.paulgraham.com/
Justin Searls Blog - https://blog.testdouble.com/
Marie Kondo — https://konmari.com/

Special Guest: Saša Jurić.

Bonus Episode: Outlaws and Wizards

podcast@smartlogic.io (SmartLogic LLC) — Fri, 13 Mar 2020 12:00:00 -0400

Elixir Outlaws invited us to join them for a special crossover episode, recorded live at Lonestar Elixir 2020. Join us for a conversation around fun and learning in development, highlights from day one of the conference, remembering Joe Armstrong, and more.

Guests / Hosts
Justus Eapen @justuseapen
Anna Neyzberg @ANeyzb
Amos King @adkron
Bruce Tate @redrapids
Susumu Yamazaki @zacky1972
Melvin Cedeno @TheCraftedGem
Tim Mecklem @tim_mecklem

Elixir Outlaws https://elixiroutlaws.com/
Lonestar Elixir https://lonestarelixir.com/

Special Guests: Amos King, Anna Neyzberg, Bruce Tate, Chris Keathley, Melvin Cedeno, Susumu Yamazaki, and Tim Mecklem.

Devon Estes from Sketch on Benchee, Performance and Training

podcast@smartlogic.io (SmartLogic LLC) — Thu, 12 Mar 2020 06:00:00 -0400

Our guest today, Devon Estes, approached us about the possible opportunity for Elixir to optimize and build out the pandas data analysis and manipulation tool, sharing why he thinks it would be a valuable addition to the Elixir open source ecosystem. But Devon joins us to contribute to our ongoing discussion about performance and training in the Elixir world, sharing about his current work on the beta for Sketch Cloud, his previous Erlang consultancy role at one of the largest banks in Europe, and the massive responsibility he carried while working on the bottom line application. He continues to advise listeners on the considerations for optimizing Erlang performance and solving database-specific problems, and the memory constraints he comes up against in the Sketch Cloud application. Devon talks about Benchee, a benchmarking library created by his friend, and how the two of them have continued to develop this tool, including its performance testing capabilities and how they deconstructed the benchmarking steps to build out the library. He also talks more broadly about the importance of considering the data when distinguishing between facts and opinions in conversations about performance.

Key Points From This Episode:

What Devon believes would be a valuable addition to the Elixir open source ecosystem.
Why optimizing and building out the pandas tool will be worth a company’s time and effort.
Devon’s experience with pandas and Python, and recognizing the opportunity for Elixir.
Working on the beta for Sketch’s Cloud that will allow real-time collaboration.
Devon’s consultancy role at Klarna, one of the largest banks in Europe.
The responsibility involved in working on the bottom-of-the-stack application at Klarna.
Considerations for optimizing Erlang performance and why you should look at the tail.
Solving the database performance problems – running queries and searches – at Klarna.
The unique memory constraints of Sketch Cloud and the problem with receiving large files.
More about Benchee, a benchmarking library, and all its performance testing capabilities.
Deciding whether a function is responsible for other things when benchmarking.
The time Devon spends on optimizing performance and the first two steps in the process.
The profiling process of determining which function is slow and writing a benchmark for it.
Distinguish between a fact and an opinion by considering the data (or lack thereof).
Keeping in mind that truth is time-bound, and it also applies to benchmarking.
Deconstructing the steps in the process of further developing Benchee.
How Devon became a maintainer of the Elixir track for Exercism, and what the role involves.

Links Mentioned in Today’s Episode:

Devon Estes — http://www.devonestes.com
Devon Estes on Twitter — https://twitter.com/devoncestes?lang=en
Devon Estes on GitHub — https://github.com/devonestes
pandas — https://pandas.pydata.org
Python — https://www.python.org
Sketch — https://www.sketch.com
Klarna — https://www.klarna.com/international/
Erlang — https://www.erlang.org
PostgreSQL — https://www.postgresql.org
Ruby — https://www.ruby-lang.org/en/
Adopting Elixir — https://www.amazon.com/Adopting-Elixir-Production-Ben-Marx/dp/1680502522
Exercism — https://exercism.io
JavaScript — https://www.javascript.com
Benchee — https://github.com/bencheeorg
SmartLogic — https://smartlogic.io/
Elixir — https://elixir-lang.org
Elixir Wizards Podcast — https://podcast.smartlogic.io

Update:
What's Inside a Reduction? http://www.devonestes.com/inside-a-reduction

Special Guest: Devon Estes.

Second Annual Lonestar Lunchisode

podcast@smartlogic.io (SmartLogic LLC) — Thu, 05 Mar 2020 06:00:00 -0500

Welcome back to the show for this special edition Lunchisode, coming to you live from the Lonestar Elixir 2020 Conference! We have a revolving door of speakers at this informal roundtable and a few friends and associates stop by to introduce themselves, share their thoughts on the conference so far and subjects that they care about. We follow up on some of the ideas raised in the Lonestar preview episode as well as hear about new and interesting ways that Elixir is being used at a variety of companies, including SalesLoft, ActiveProspect, SmartRent and more! We also consider the place of Elixir education and go deeper on the topic of finding fun and meaning in our programming pursuits and beyond. Join us for this special edition and stay tuned for the next installment soon.

Key Points From This Episode:

Thoughts on the conference so far — the talks and venue.
SalesLoft's Elixir adoption and how the decision was made by those in power.
Bruce Williams' current work at GitHub and his project on Absinthe.
Elixir usage in Mexico and the prominent organizations and companies that use it.
Some information on the Observability Working Group and what they are currently busy with.
Differences between tracing and logging; tracing is essentially distributed logging.
What it means for the programmer when they bump up against a challenge!
The amount of effort that should go into developing entry points for new Elixir developers.
Education in the Elixir space and the success of the bootcamp model.
Considering the ongoing utility of unit tests and changing up training strategies.
The work done by SmartRent in real estate and how Elixir fits into their tech stack.

Links Mentioned in Today’s Episode:

Special Guests: Brain Naegele, Bruce Tate, Bruce Williams, Dave Thomas, Frank Kumro, Jon Carstens, Ricardo Echavarria, Steve Bussey, Todd Resudek, and Zach Thomas.

Bonus Toddcast & Lonestar Preview

podcast@smartlogic.io (SmartLogic LLC) — Thu, 27 Feb 2020 07:30:00 -0500

This week we're delighted to share a special format bonus episode!

We are joined by guest co-host Todd Resudek as well as a number of guests who each share a little bit about what they're working on and in many cases their upcoming presentations at Lonestar Elixir.

Special episode guests:

Angel Jose, Senior Platform Engineer at Cars.com
Dave Lucia, VP of Engineering at SimpleBet
Greg Mefford, Senior Back-End Engineer at Bleacher Report
Melvin Cedeno, Elixir Developer at SplitGyms
Zach Thomas, API Developer at Blinker

Most of our guests weigh in about their upcoming presentations at the event and we also get to chat about a few near and dear topics with our rotating cast. We hear about where they are working, their experiences with Elixir and their thoughts on education and company culture. It's an unusual episode but one we are so glad to have had the chance to make! We also find time to touch on our focus for the next season of the podcast, which is very exciting for all of us over here at the show. Remember to stay plugged in for more on Lonestar Elixir and attend if you can!

Key Points From This Episode:

Some thoughts on LiveView and its adoption by new developers.
Angel's work at Cars and how they are using Elixir and LiveView to rewrite everything.
Chatbots and the immediate benefits of using Elixir to rewrite them.
The elevator pitch on SimpleBet and the tech stack, skillset and ecosystem of the company.
Why Dave and his team have moved away from Rust!
A quick tease of what to expect for Season 4 of the podcast: Architecture of Applications!
How Bleacher Report is using Elixir to build the 'third space' for sports fans.
Team building and expansion at Bleacher Report and the stages of scaling.
A sneak preview of Greg's upcoming talk at Lonestar!
How Greg got started with Nerves and why it has a special place in his heart.
The theme of Melvin's talk at Lonestar; untraditional routes and emotions in tech.
Considering the usefulness of boot camps, the value of ISAs and CS programs.
Zach's background in Elixir and his current work at Blinker with the language.
Experiences at Turing and in liberal arts during college.
Zach's Lonestar talk elevator pitch: 'Getting the Frog out of the Well'.
The allegory of the cave, 'what is water' and how this differs from Zach's idea.
Why don't we like statically typed things as much as we should?

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Lonestar Elixir 2020 — https://lonestarelixir.com/
Todd Resudek — https://medium.com/@toddresudek
Todd Resudek on Twitter — https://twitter.com/sprsmpl
Angel Jose — https://github.com/ajose01
Dave Lucia — https://github.com/davydog187
Greg Mefford — https://github.com/GregMefford/blinkchain
Melvin Cedeno — https://gist.github.com/normanrs/eeb5cc91cb10eeb7d3e43168396efb27
Zack Thomas — https://github.com/zeam-vm/pelemay
Sophie DeBenedetto — http://sophiedebenedetto.nyc/
LiveView — https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
ElixirConf — https://elixirconf.com/events
Cars — https://www.cars.com/
SimpleBet — https://www.simplebet.io/
Full Stack Developer Horse Drawing Meme — https://knowyourmeme.com/photos/1624070-unfinished-horse-drawing
Conway's Law — https://www.thoughtworks.com/insights/blog/applying-conways-law-improve-your-software-development
ElixirConf 2019 - Lighting Talk - Are There Benefits Of Crying In Tech — https://www.youtube.com/watch?v=oW5Plkroyxk
TRON — https://www.rottentomatoes.com/m/tron
Smart Mirror Blog Post — https://medium.com/@toddresudek/building-a-smart-mirror-with-phoenix-liveview-18193ee6438f
Bleacher Report — https://bleacherreport.com/
Team Topologies — https://teamtopologies.com/
Nerves — https://nerves-project.org/
Turing — https://turing.io/
CIRR — https://cirr.org/
David Heinemeier Hansson — https://dhh.dk/
Blinker — https://www.blinker.com/
David Foster Wallace — http://www.davidfosterwallacebooks.com/
Gödel, Escher, Bach — https://www.goodreads.com/book/show/24113.G_del_Escher_Bach

Special Guests: Angel Jose, Dave Lucia, Greg Mefford, Melvin Cedeno, Todd Resudek, and Zach Thomas.

Alex Garibay and Mike Binns from DockYard on Hiring and Training

podcast@smartlogic.io (SmartLogic LLC) — Thu, 20 Feb 2020 06:00:00 -0500

Today on the show, we’re joined by Mike Binns and Alex Garibay of DockYard. In this episode, Mike and Alex share their journeys of how they came to work at DockYard and give us a view into DockYard’s hiring and training processes, systems, and philosophies. Here they share what they enjoy most about working at DockYard and their emphasis on being supported in your continual growth as an employee and human being.

Key Points from This Episode:

Find out how Mike and Alex both got their jobs at DockYard in 2016.
Working for a fully remote company: Mike and Alex share their experiences.
The amount of languages used at DockYard and what the day-to-day looks like.
React VS Ember: Find out DockYard’s opinion on the debate between the two.
How to know whether you should be using JavaScript or Live View on your projects.
The importance of inclusion and empowerment in the onboarding process at DockYard.
How to support and train new employees in “soft” skills, such as communication.
Personal strategies Mike and Alex use to help “soften the blow” of feedback and criticism.
Discover what DockYard does to support the learning growth of their employees.
Learn more about DockYard Friday and the exciting projects that have emerged from it.
Helpful resources for learning Elixir and how to remain a curious learner as a developer.
Find out the top skills that make a great engineering manager at DockYard today.

Links Mentioned in Today’s Episode:

Mike Binns on Twitter — https://twitter.com/1stAvenger
Mike Binns on LinkedIn — https://www.linkedin.com/in/mikebinns
Alex Garibay — https://alexgaribay.com/
Alex Garibay on Twitter — https://twitter.com/_AlexGaribay
Alex Garibay on LinkedIn — https://www.linkedin.com/in/alexandergaribay/
DockYard — https://DockYard.com/
SmartLogic — https://smartlogic.io/
RailsConf — https://railsconf.com/
Chris McCord — http://chrismccord.com/
Ember — https://emberjs.com/
Live View — https://support.google.com/maps/thread/11554255?hl=en
Elixir in Action — https://www.amazon.com/Elixir-Action-Sa%C5%A1a-Juri-cacute/dp/1617295027
Elixir Conf 2014 Keynote by Dave Thomas — https://www.youtube.com/watch?v=5hDVftaPQwY
Sarah Drasner — https://sarahdrasnerdesign.com/
Lonestar Elixir — https://lonestarelixir.com/
Programming Phoenix — https://www.amazon.com/Programming-Phoenix-Productive-Reliable-Fast/dp/1680501453
Jason Goldberger — https://twitter.com/jsonlouis_

Special Guests: Alex Garibay and Mike Binns.

Sean Lewis from Divvy on Performance, Hiring and Training

podcast@smartlogic.io (SmartLogic LLC) — Thu, 13 Feb 2020 06:00:00 -0500

Today on Elixir Wizards we are delighted to be joined by Sean Lewis, a senior backend architect at Divvy. One of the many impressive facts about Sean is that he is entirely self-taught, from dabbling in Python and coding to eventually writing a bunch of Ruby tests and working his way up in the product development sphere. In his free time, he likes to play around with electronics and work on other tech-related projects such as developing custom smart home devices. In this episode, Sean discusses his recent Meetup talk on the implementation of Broadway and explains Divvy’s tech stack choices that include React, Elixir, and Python. He dives into the topic of hiring for Elixir, outlining the challenges and providing strategies and resources to equip new developers in the area of functional programming. For Sean, the most important aspect of onboarding is teaching newcomers to ask the right questions since this is the foundation of the problem-solving process. He shares about Divvy’s approach to recruitment, his role as mentor, how they go about retaining and continuously growing their developers, the importance of being teachable, and then Sean concludes by giving listeners practical advice for ensuring data fidelity.

Key Points From This Episode:

Sean’s self-taught journey and role as senior backend architect at Divvy.
The smart home projects he has recently worked on, including a smart garage.
An overview of Broadway and Sean’s Meetup talk regarding implementation.
The straightforward tech stack at Divvy: React, Elixir, and Python.
The difficulty of hiring for Elixir and finding fintech companies that use Elixir.
Strategies and resources for training new engineers on Elixir and functional programming.
Why fintech works well with functional programming in the context of authorization.
Training state-minimization as a primary concern.
Onboarding: a process of teaching developers to ask the right questions.
Divvy’s approach to finding and recruiting new employees.
Thoughts on why so many Utahn companies use Elixir and the city’s exponential growth.
How Sean was recruited by Divvy, his progression to architect, and his role as a mentor.
Critical practices for onboarding developers, including assimilating them into the culture.
How Devvy continues to grow and retain its engineers.
The importance of challenging yourself, constantly learning, and staying teachable.
Implementing high-quality checkpoints and other advice for ensuring data fidelity.

Links Mentioned in Today’s Episode:

Sean Lewis on LinkedIn — https://www.linkedin.com/in/sean-lewis-40375077/
Sean Lewis on Twitter — https://twitter.com/fricsean?lang=en
Sean Lewis on GitHub — https://github.com/SophisticaSean
Divvy — https://getdivvy.com
Ruby — https://www.ruby-lang.org/en/
Broadway — https://hexdocs.pm/broadway/amazon-sqs.html
Utah Elixir Meetup — https://www.meetup.com/utah-elixir
React — https://reactjs.org
Elixir — https://elixir-lang.org
Susumu Yamazaki on Twitter — https://twitter.com/zacky1972
Domain Modeling Made Functional — https://www.amazon.com/Domain-Modeling-Made-Functional-Domain-Driven-ebook/dp/B07B44BPFB
Slack — https://slack.com/
MongoDB — https://www.mongodb.com
PostgreSQL — https://www.postgresql.org
Elixir Wizards Podcast — https://podcast.smartlogic.io
SmartLogic — https://smartlogic.io/

Special Guest: Sean Lewis.

Paul Schoenfelder and Hans Elias Josephsen on Lumen and Performance

podcast@smartlogic.io (SmartLogic LLC) — Thu, 06 Feb 2020 06:00:00 -0500

In line with our current working-with-Elixir theme, today we’re talking about performance with Paul Schoenfelder and Hans Elias Josephsen from DockYard. The two have been working on Lumen, and in this episode, they discuss how this project is incorporated with WebAssembly, a binary instruction format that ultimately allows Elixir to be run in the browser and preserve the semantics of the language. Paul and Hans talk about the specific aspects of Lumen they are working on; the data flow and process of writing Elixir; and the compiler, interpreter and run-time functions involved. Joining in this conversation, you will also hear how they approached starting developing Lumen as a brand new compiler, researching, the aspects Paul wanted to tackle first, and when users can expect Lumen to be released. We also talk about the performance concerns they encountered along the way, the many reasons why Rust was their programming language of choice, and their thoughts on generic associated types in Rust.

Key Points From This Episode:

• How Paul and Hans got introduced to Elixir and working for DockYard.
• An overview of what Lumen is and how it relates to WebAssembly.
• WebAssembly code to run Elixir in the browser and preserve the semantics of the language.
• The different aspects of the Lumen project that Paul and Hans are involved in.
• The data flow and process when writing Elixir and how the compiler function features.
• Taking advantage of optimizations that can be performed on the code that is generated.
• An explanation of the interpreter and run-time parts of the project.
• How they approached the major task of starting with a brand new compiler.
• The process of researching and why Paul wanted to get a frontend in place first.
• The production readiness of Lumen and when they expect to release it.
• Performance concerns they encountered during development.
• The relevance of code size for the WebAssembly backend to be usable.

• Why Rust was the best choice for building the compiler.
• Using Elixir to generate a standard binary that can run on any machine.
• A description of generic associated types in Rust and why they are controversial.

Links Mentioned in Today’s Episode:

Paul Schoenfelder on LinkedIn — https://www.linkedin.com/in/gotbones/
Paul Schoenfelder on Twitter — https://twitter.com/gotbones?lang=en
Hans Elias Josephsen on Twitter — https://twitter.com/hansihe
DockYard — https://dockyard.com
Elixir — https://elixir-lang.org
WebAssembly — https://webassembly.org
Rust — https://www.rust-lang.org
JavaScript — https://www.javascript.com
C++ — http://www.cplusplus.com
SmartLogic — https://smartlogic.io/

Special Guests: Hans Elias Josephsen and Paul Schoenfelder.

Sophie DeBenedetto and Meryl Dakin on Training and Building Elixir Projects Under Constraints

podcast@smartlogic.io (SmartLogic LLC) — Thu, 30 Jan 2020 06:00:00 -0500

Today on the show we are joined by Sophie DeBenedetto from GitHub and Meryl Dakin from Frame.io to talk about the processes involved in training others and building Elixir projects. They share about studying and working together at the Flatiron School and what they do now in their respective new roles at Github and Frame.io. During their time at Flatiron, they worked on various projects, often collaborating with engineering teams from other companies and having to train these team members in Elixir. They talk about how they managed to develop new features while simultaneously onboarding new people and getting everyone on the same page. For them, the pair programming model had been most beneficial, and they discuss the habits and practices they implemented to encourage team members, optimize each learning experience, and share knowledge during training events. Sophie and Meryl also share the Elixir-specific challenges they encountered while developing applications for 2U, how Elixir’s failure-first programming capability guided them, how they prepare for training workshops, and the productivity hacks that keep them focused and energized.

Key Points From This Episode:

• How Sophie and Meryl know each other from working and studying at the Flatiron School.
• Frame.io as a tool that facilitates the communication between video editors and clients.
• Meryl’s new role as a full-stack developer working with Elixir and React.
• The projects they worked on at Flatiron and partnering with various companies like 2U.
• Their secret to developing new features while also introducing new team members to Elixir.

• The benefits of pair programming and teaching a programming language to others.
• Reserving time to celebrate wins and knowledge share during training events.
• Key lessons they learned from their collaboration with the 2U team.
• Elixir-specific challenges during the development of the applications project with 2U.
• How Elixir’s failure-first programming capability ultimately helps developers.
• Sophie and Meryl’s experience using LiveView at Flatiron and the problems encountered.
• The work that went into preparing for training workshops.
• Advice for teaching someone who is not technical to become a working developer.
• Productivity hacks to stay focused and regain energy.

Links Mentioned in Today’s Episode:

Sophie DeBenedetto on LinkedIn — https://www.linkedin.com/in/sophiedebenedetto/
Sophie DeBenedetto on Twitter — https://twitter.com/sm_debenedetto
Meryl Dakin in LinkedIn — https://www.linkedin.com/in/meryldakin/
Meryl Dakin on Twitter — https://twitter.com/meryldakin
Eric Oestrich — https://oestrich.org
Frame.io — https://frame.io
GitHub — https://github.com
Flatiron School — https://flatironschool.com
Elixir — https://elixir-lang.org
React — https://reactjs.org
2U — https://2u.com
Kubernetes — https://kubernetes.io
Ruby — https://www.ruby-lang.org/en/
Elixir School — https://elixirschool.com/en/
Drawing on the Right Side of the Brain — https://www.amazon.com/Drawing-Right-Side-Brain-Definitive/dp/1585429201
Etsy — https://www.etsy.com
EMPEX NYC Conference — https://empex.co/nyc.html
SmartLogic — https://smartlogic.io/

Special Guests: Meryl Dakin and Sophie DeBenedetto.

Brooklyn Zelenka on Functional Programming

podcast@smartlogic.io (SmartLogic LLC) — Thu, 23 Jan 2020 06:00:00 -0500

In today’s episode we have one of our favorite recurring guests, Brooklyn Zelenka, joining us once again! Brooklyn has been on the show in both the first and second seasons to speak about Elixir and functional programming. In those conversations, it came up that this topic is far from exhausted, and since Season 3's theme is working with Elixir, we thought it would be great to have Brooklyn on for a third time. Today, Brooklyn does not speak to Elixir specifically though, but on functional programming more broadly. Fission, her company which is working on developing next-generation hostless apps, actually uses Haskel, but Brooklyn has a ton of experience across the board. She gives us some great insights into what makes the functional versus OOP paradigm great and helps us to understand some of the inner workings of both worlds, talking about abstraction, application, data orientation, and more. Interestingly, Brooklyn does employ some imperative programming in her company through the use of Typescript, but uses a functional style to get around the context switch. We spend some time toward the end of the show digging deeper into macros, and Brooklyn helps to revise understandings of them as code which writes more code as well as clarifies the term 'homoiconic' as it relates to ASTs. Brooklyn covers a whole lot more today so hop on for a deep dive into functional programming with today's great guest.

Key Points From This Episode:

• Why Brooklyn uses FPE: it can be reused and reasoned about.
• Two things that functions provide: abstraction and application.
• Data orientation and hiding information: imperative vs functional paradigms.
• Understanding imperative programming: it’s less structured and hard to reason about.
• Challenges experienced imperative programmers face with functional programming.
• Differences between Elixir, Erlang, Haskel, Elm, and Clojure.
• Using Clojure: tradeoffs, distinctions, tooling, flexibility, and compatibility with Java.
• The language Brooklyn could use if only one existed: Racket.
• Bridging functional and imperative paradigms through disciplined use of style.
• Segfaults in Haskell related to its compatibility with lib C.
• How to use Musl instead of lib C by employing docker files.
• Algebraic types and why static types aren’t hindrances in functional languages.
• Preferences for tests or proofs and their role in finding types valuable.
• Macros as compile-time functions that are difficult to debug.
• A definition of a ‘homoiconic’: high-level syntax which represents the AST.
• What makes C macros different from Lisp ones.
• Architecture in Elixir and the need for a more user-friendly Haskell.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Brooklyn Zelenka on LinkedIn — https://www.linkedin.com/in/brooklynzelenka/
Fission — https://fission.codes/
Seven Languages in Seven Weeks — https://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X
Chris Keathley — https://keathley.io/
Hackers and Painters — https://www.amazon.com/Hackers-Painters-Big-Ideas-Computer/dp/1449389554
Paul Graham — http://www.paulgraham.com/

Special Guest: Brooklyn Zelenka.

Bruce and Maggie Tate from Groxio on Training

podcast@smartlogic.io (SmartLogic LLC) — Thu, 16 Jan 2020 06:00:00 -0500

Groxio is a great platform that allows programmers to learn new languages easily and broaden their horizons. Our guests today are the team behind Groxio, Bruce and Maggie Tate! In our discussion, we cover the basics and the not so basics of what they do, from how they got into the Elixir world and founded Groxio to the conferences they run and the books they have published. We also talk about the benefits of learning multiple languages and Bruce makes a strong argument for the influence that smaller coding languages have had on his Elixir skills. Maggie and Bruce open up about having a professional and personal partnership and how they manage their marriage and businesses side by side. To finish off we hear about all the exciting things to expect at the Lonestar Conference this year and how it is going to be even better than last year's!

Key Points From This Episode:

• Bruce and Maggie's background in Elixir and how they started Groxio.
• What sets Groxio apart from similar technical education companies.

• The inspiration that Bruce got from the Crystal and Pony languages.
• How curiosity and dopamine are linked; following new and interesting pathways.
• Maggie and Bruce's personal and professional partnership and how they manage it.
• The Elixir books that still need to be written and under-appreciated published ones.
• A guide to Bruce's books and which to read for particular applications.
• Running a conference; the stressful and fun parts for Maggie and Bruce.
• Aspirations for the conferences and what to expect at this year's events.
• Exciting speakers that will be appearing at the Lone Star Conference.
• The controversy around the new Lone Star bat logo!
• A few special plugs from our guests for things they are passionate about.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Bruce and Maggie Tate — https://grox.io/about
Bruce Tate on Twitter — https://twitter.com/redrapids
Maggie Tate on Twitter — https://twitter.com/gardenertate
Groxio — https://grox.io/
Gig City Elixir — https://www.gigcityelixir.com/
Lone Star Elixir — https://lonestarelixir.com/
Crystal — https://crystal-lang.org/
Pony — https://www.ponylang.io/
Joe Armstrong — https://joearms.github.io/
Elixir in Action — https://www.amazon.com/Elixir-Action-Sa%C5%A1a-Juri-cacute/dp/161729201X
Designing Elixir Systems — https://www.amazon.com/Designing-Elixir-Systems-OTP-Self-healing/dp/1680506617/
Andrea Leopardi — https://confengine.com/user/andrea-leopardi

Special Guests: Bruce Tate and Maggie Tate.

Dan Ivovich from SmartLogic on Hiring and Training

podcast@smartlogic.io (SmartLogic LLC) — Thu, 09 Jan 2020 06:00:00 -0500

On today's show, we are joined by Dan Ivovich from our team here at SmartLogic! Dan is the Director of Development Operations and has already been a guest and cohost a few times on the show. Today we are talking about hiring and training and his experience with these tasks at the company and especially concerning Elixir. We discuss the challenges Dan has faced in recruiting and the ways in which SmartLogic has lined up resumes and possible candidates through events and meetups. Dan explains some of the difficulties that are common for programmers transitioning into Elixir and how the company approaches the tasks of onboarding and ongoing support. We also get into Dan's favorite resources and tools for staying abreast of Elixir and his recommendations for practices to learn fast as a newcomer before he explains how he thinks about continual learning and expanding his own skillset. The conversation finishes with some thoughts and reflections on functional programming from our guest, so make sure to tune in for all of that and more!

Key Points From This Episode:

Dan's role at SmartLogic and how he leads the team.
Recruiting new employees; collecting resumes and attending events.
Challenges posed by recruiting good Elixir programmers and who to look for.
Sticking points for people transitioning into Elixir from other languages.
The stack at SmartLogic and the number of projects based in Elixir.
Onboarding at the company; skills that are transferable to Elixir.
Professional development and ongoing support for team members.
Dan's favorite tools and resources for learning Elixir.
Continual learning and Dan's strategies for growing his skillset.
A simple definition of functional programming and Dan's early experiences with it.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Dan Ivovich — https://www.danivovich.com/
Dan Ivovich on Twitter — https://twitter.com/danivovich
ElixirConf — https://elixirconf.com/events
Java — https://www.java.com/
Ruby — https://www.ruby-lang.org/
Python — https://www.python.org/
Rails — https://rubyonrails.org/
Rust — https://www.rust-lang.org/
GO — https://golang.org/
Twitch — https://www.twitch.tv/
Bruce Tate — https://codesync.global/speaker/bruce-tate/
Scala — https://www.scala-lang.org/

Special Guest: Dan Ivovich.

Eric Meadows Jönsson on Hex and Working with Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 02 Jan 2020 06:00:00 -0500

We are happy to be joined in this episode by Eric Meadows Jönsson, creator of the hexpm package manager, and an amazing resource who works tirelessly to build the Elixir community. Eric presently works at Brex and was part of the core team at Forza previously. In keeping with our current topic of all things working with Elixir, Eric takes a deep dive into the work he is doing to optimize various interfaces at Brex. He gives us the rundown on the static compile-time checking project he is working on, talking about his aims to build in different warnings and what we can expect from the new release in that regard. You’ll also hear about Eric’s journey learning Elixir and how he had to change his OOP mindset when he got introduced to functional programming at university. He shares the story behind hexpm and Mint, his thoughts about the future of Hex, and some of the processes around accessing the private repositories on its website. We also hear more about Eric’s hiring procedure while working at Forza, how he teaches functional programming to students at ElixirConf, and some of the major performance bottlenecks he experiences using Hex. Tap into the incredible resource that is Eric and hear more about how you can link with him online to learn further in the future by tuning in!

Key Points From This Episode:

Jose Valim, the Ecto library, and Eric’s journey with Elixir since 2012 at a coding camp.
Early-stage static compile-time checks that Eric is adding to the compiler at Brex.
Whether the static compile-time checks Eric is adding constitute a type system or not.
Static compile-time checks in the current system such as undefined function warnings.
Features of the new static compile-time check release: refactored checks, etc.
Currently, these checks happen at compile-time, or when Elixir compiles into the byte code.
Whether these checks will move into BEAM: currently it’s in Elixir and at an early stage.
The Erlang compiler already does type inference during compilation.
Eric’s Erlang proficiency and why he had to brush up on it through using Elixir.
What makes Eric helpful with Hex: his debugging skills and availability to answer questions.
How Eric got started with Hex adding an intake for Git packages.
The story behind Hex regarding ties to Elixir and Devinus from Pool Boy.
Todd’s perspective on Eric as a smart and nice mentor who sleeps very little.
Changes that Eric sees happening in Elixir.
Hex will no longer support older Elixir versions so that it can enable better maintenance.
Another change will be a refactoring of the resolution version algorithm.
Security-related updates that Todd has been working on.
Private versus public repositories on the hex.pm website.
Hiring challenges at Forza and how Eric found the right team out of scarce people.
Eric looks for people who love being programmers and have a passion for learning.
Tactics Eric uses to train functional programming such as hosting ElixirConf workshops.
Important fundamentals in functional programming: using data structures to model data, etc.
Differences between functional and object-oriented programming: data vs classes.
The role of types in Eric coming to understand functional programming better.
Performance bottlenecks in Hex such as dependency resolution.
How every package manager/resolver compromises, exemplified by NPM and Rebar3.
Origins of Mint: wanting http2 support for Hex, and more.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Eric Meadows Jönsson on GitHub – https://github.com/ericmj
Eric Meadows Jönsson on Hexpm — https://hex.pm/users/ericmj
Brex — https://brex.com/
Todd Resudek on LinkedIn — https://www.linkedin.com/in/toddresudek
Justus Eapen on LinkedIn — https://www.linkedin.com/in/justuseapen/
Eric Oestreich on LinkedIn — https://www.linkedin.com/in/eric-oestreich-8b55aab/
hexpm on GitHub — https://github.com/hexpm
Google Summer of Code — https://summerofcode.withgoogle.com/
Jose Valim on GitHib — https://github.com/josevalim
Pool Boy — https://github.com/devinus/poolboy
Devin Alexander Torres — https://github.com/devinus
Voitech — https://www.voitech.biz/
Hex — https://hex.pm/
hexpm specifications — https://github.com/hexpm/specifications
Slack — https://slack.com
IRC —https://hexchat.github.io/
Forza — https://www.forzafootball.com/women
ElixirConf — https://elixirconf.com/events
Chalmers University — https://www.chalmers.se/en/Pages/default.aspx
Fastly — https://www.fastly.com/
NPM — https://www.npmjs.com/
Rebar 3 — https://github.com/erlang/rebar3
Mint — https://www.mint-lang.com/
Ruby Gems — https://rubygems.org/
Andrea Leopardi on GitHub — https://github.com/whatyouhide?tab=overview&org=ForzaElixir

Special Guest: Todd Resudek.

Chris Keathley on Performance and Functional Programming

podcast@smartlogic.io (SmartLogic LLC) — Thu, 19 Dec 2019 06:00:00 -0500

Our guest on the show today is blogger, software cowboy, and podcast host Chris Keathley. Chris is a senior engineer at Bleacher Report, co-host of Elixir Outlaws, and writer of an assemblage of open-source software. He joins us today to speak about his new projects, his journey with functional programming, and what it is like to run Bleacher Report’s infrastructure on Elixir. Chris gives us the lowdown on Norm, a data validating interface he recently completed, weighing in on how it is different from Dialyzer and what it can offer as far as scalability. We hear more about how Chris got introduced to Elixir through Haskell, why he wishes he learned Clojure sooner, and why Ruby on Rails isn’t going anywhere soon.

Chris also gets into the tradeoffs these languages make to correlate with Erlang. He argues that Elixir can only be more widely adopted if more people build cool things in it, and then lays out some of its power in supporting Bleacher Report’s user interface. We pick Chris’s brain about what his company is trying to optimize at the moment and hear about their preference for capacity over speed, and their techniques for failing gracefully during traffic spikes. Chris tells us how much he loves Elixir due to its use of ETS and other functionality which allows Bleacher Report to keep running even above capacity. Finally, we hear about some of the observability practices that Bleacher Report uses when deploying new systems and predicting future spikes. Plug in for a great conversation and hear why you should get building with Elixir now!

Key Points From This Episode:

Chris’s explanation of Norm, his new software that describes data moving through a system.
Chris’s introduction to functional programming through learning Haskell, Clojure, and Elixir.
What makes a great functional language: immutable data and first class functions.
Things that make Clojure great, such as its thought out, holistic design.
Characteristics of Cons lists versus RRB trees, and what makes the latter better.
An acknowledgment of the necessity of the tradeoffs Elixir makes to interact with Erlang.
A little bit about the language Chris wrote to do the admin of code challenges in.
Why Ruby (on Rails) will not be replaced by Elixir due to commoditization that surrounds it.
An argument that Elixir can only be more widely adopted if more people build with it.
Why any language can build any program thus comparisons between them are arbitrary.
Where Chris sets the bar as to when something is performant.
Chris’s preference for high user capacity capability over speed of delivery at Bleacher Report.
Optimization projects at Bleacher Report such as using few boxes and handling traffic spikes.
Things Chris loves about Elixir such as its ability to deliver more from its boxes.
Elixir’s use of ETS and how Chris coded a complex problem in half a day using it.
How Chris detects spikes using time series, StatsD, and other observability tools.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Chris Keathley on GitHub — https://github.com/keathley
Chris Keathley Blog — https://keathley.io/
ElixirConf 2019, Contracts for Building Reliable Systems presented by Chris Keathley — https://www.youtube.com/watch?v=tpo3JUyVIjQ
The Big Elixir 2019 - Keynote: Adoption - Brian Cardarella — https://www.youtube.com/watch?v=ghpIiQKRfQ4
Bleacher Report — https://bleacherreport.com/
Elixir Outlaws Podcast — https://elixiroutlaws.com/
Norm — https://github.com/keathley/norm
Dialyzer — http://erlang.org/doc/man/dialyzer.html
Haskell — https://www.haskell.org/
Clojure — https://clojure.org/
Erlang — https://www.erlang.org/
Chris Okasaki — https://github.com/chrisokasaki
Discord — https://discordapp.com/company
StatsD — https://www.datadoghq.com/blog/statsd/
Prometheus — https://prometheus.io/
Opentracing — https://opentracing.io/

Special Guest: Chris Keathley.

Justin Schneck & Frank Hunleth on Nerves and Performance – Working with Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 12 Dec 2019 06:00:00 -0500

On today’s show, we welcome Justin Schneck and Frank Hunleth, luminaries from the Nerves team! We take a dive into the world of Nerves with them, covering themes of performance, problem-solving, transitioning to hardware, and breakthroughs in the field. We begin with a conversation on how Elixir handles performance issues on the range of devices they support and Frank gets into how the team solved an early boot time discrepancy between a PC and a Raspberry Pi board. Other big themes for today are ironing out the kinks in the system registry model and merging Erlang and into hard real-time. After squeezing some information out of the guys about their use of ugly code hacks we get into some visionary decisions as well as things the team wished they could have done differently at Elixir (see the release of the new networking stack). Finally, we end off with what Frank and Justin are excited about as far as developments in the Nerves community, so be sure to plug into this one!

**Key Points From This Episode:

What Justin did in Tokyo, from soaking in hot springs to debugging in Kanji.
An explanation of The Erlang Ecosystem Foundation, an embedded systems working group.
The use of the VintageNet library for setting up multi-hold nerve networks.
How Elixir handles performance issues on the range of devices they support.
A breakdown of troubleshooting processes as far as acceleration with FPGAs.
Issues with dependencies that occur when starting a network node on a Nerves device.
How Elixir is trying to evolve past the system registry model.
Identifying the challenge of reconfiguring early boot time which Elixir is facing.
How Elixir solved a load time discrepancy between a PC and the Raspberry Pi board.
Which situations require hardware when Elixir is too slow, such as video encoding.
Japanese research into GPU, FPGA and SIMD optimization involving wrapping code blocks.
Merging Erlang which is soft real-time into hard real-time.
Examples of ugly but fast code hacks in Elixir.
Hacks and the pitfalls of system registry such as returning to a prompt when an app crashes.
Things Elixir would have done differently in working with Nerves if could they rewind time.
Why releasing a new networking stack means Elixir could have done things differently.
Lessons Justin and Frank learned moving from OTP to functional programming at Elixir.
Exciting new developments and releases in the Nerves community.

Links Mentioned in Today’s Episode:

Nerves Project — https://nerves-project.org/
SmartLogic — https://smartlogic.io/
ElixirConf US — https://elixirconf.com/events
The Erlang Ecosystem Foundation — https://erlef.org/
GRiSP — https://www.grisp.org/
Vintage Net — https://github.com/nerves-networking/vintage_net
Joe Armstrong — https://joearms.github.io/
Erlang — https://www.erlang.org/
Linux — https://www.linux.org/

Special Guest: Frank Hunleth.

Brad Traylor of Podium on Training & Hiring – Working with Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 05 Dec 2019 06:00:00 -0500

Our theme this season is working with Elixir, and joining in the conversation today is Brad Traylor from Podium. Brad shares his expertise in hiring and training for Podium, a position he is passionate about since it gives him the opportunity to work on the people and tech side of things. We begin by hearing a bit of Brad’s background, when and how he was first introduced to Elixir and the standout qualities that attracted him to Podium. He discusses the hiring process, including what he looks for in an engineer, why they don’t recruit much but rather work with referrals, the step-by-step of onboarding new devs and the resources he recommends to anyone in the industry. Another great talk with a stand-up guy — be sure to tune in!

Key Points From This Episode:

When Brad was first exposed to Elixir and how he became the engineering manager.
Searching for rocket ship startups and what specifically drew him to Podium.
Having a desire to work with the people and the tech side of the industry.
The growth trajectory of Podium from a management perspective.
Hiring predominantly from referrals rather than recruiting developers.
The biggest challenge with hiring Elixir devs, including the scarcity of good ones!
Two things Brad looks for when hiring engineers: the drive to learn and a cultural fit.
The benefit of hiring younger developers.
Thoughts on training different languages and adding them to Podium’s tech stack.
An overview of the typical onboarding process for a new engineer.
Elixir 101 and other ways they keep training and refining the skills of developers.
Resources that Brad has recently learned and those he always recommends to devs.

**Links Mentioned in Today’s Episode:

Brad Traylor on LinkedIn — https://www.linkedin.com/in/bradtraylor
Brad Traylor on Twitter — https://twitter.com/btjordan23
Podium — https://www.podium.com
SmartLogic — https://smartlogic.io/
Elixir — https://elixir-lang.org
University of Michigan — https://umich.edu
Java — https://www.java.com/en/
Python — https://www.python.org
Rust — https://www.rust-lang.org
Ruby — https://www.ruby-lang.org/en/
TypeScript — https://www.typescriptlang.org
Pragmatic Institute — https://www.pragmaticinstitute.com/courses
The Manager’s Path — https://www.amazon.com/Managers-Path-Leaders-Navigating-Growth-ebook/dp/B06XP3GJ7F
Camile Fournier — https://twitter.com/skamille

Special Guest: Brad Traylor.

José Valim, Creator of Elixir

podcast@smartlogic.io (SmartLogic LLC) — Tue, 26 Nov 2019 06:00:00 -0500

Today on Elixir Wizards we are joined by none other than José Valim, the inventor of Elixir! Coming from the Ruby on Rails world, José found his way to functional programming and we hear all about the evolution of his philosophy and thought process around the time of the creation of the language. He gives us some great insight into why functional programming is so appealing to him and the problems he wanted to solve by creating Elixir. We chat about other languages and his use of Erlang, Elixir's three biggest influences and some important characters in the story. José also shares a bit of personal, behind the scenes stuff about his schedule and how he tries to stay as productive as possible. We finish off the chat, talking about performance and the measures José has taken in this regard. For all this and more from a true Elixir wizard, be sure to tune in!

Key Points From This Episode:

José's thoughts on our recent podcast name-change!
The first steps for José in the process of writing a language.
Reason for José's decision to step out of the Ruby on Rails world.
The 'aha' moment that José had when moving into functional programming.
Some of the inspiration for Elixir from other languages.
A few of the people that have mentored and inspired José in his career.
The research and development phase for Elixir and José strategy for this.
José's work habits, his typical day and the influence of his kids on his flow.
Why José still considers himself an Elixir programmer despite his proximity.
Elixir and machine learning; why the two are not more closely linked.
Steps in the measurement process for José and Elixir.
The time that José has spent on the performance side of the language.
Sacrifices and substitution in optimizing Elixir's performance.
Some of the things on the horizon that are exciting José.

Links Mentioned in Today’s Episode:

SmartLogic
José Valim
Plataformatec
Harry Potter
Erlang
Ruby
Clojure
ElixirConf

Special Guest: José Valim.

Dr Jim Freeze on Hiring, Training, and Functional Programming – Working with Elixir

podcast@smartlogic.io (SmartLogic LLC) — Thu, 21 Nov 2019 06:00:00 -0500

Welcome to Elixir Wizards, today we are joined by Dr. Jim Freeze to talk about his passion for and history in Elixir and functional programming. Dr. Freeze is one of the organizers of one of our favorite things in the world, Elixir Conf! He shares his story of coming to functional programming and his early days with Elixir, what he sees as the most important aspects of the conference before diving into what is on offer for those that attend. We talk about how employers can get Elixir newcomers up to speed on the language and the most effective ways Dr. Freeze stays abreast of developments in the field. Our guest also recommends a few resources for those wanting an introduction to Elixir and makes a great argument for the usefulness of a functional approach to programming. For all this and a whole bunch more, join us today!

Key Points From This Episode:

How Dr. Freeze got started with Elixir and his programming background.
A little bit about the early days of Elixir Conf and what the first events were like.
The particulars of Dr. Freeze's doctorate and his title.
Education, networking and how Elixir Conf fits into the developer hiring game.
The training that is offered at the conference and the philosophy to serving attendees.
Dr. Freeze's recommendations for employers bringing newbies up to speed with Elixir.
How our guest continues his learning and stays focused on what is necessary.
Useful resources and materials for Elixir, according to Dr. Freeze.
Contemplating functional programming and its key components.
Why to consider functional programming coming from an object-based background.
The biggest hurdles in moving over to functional programming and Elixir.
Following the data and how much the simplicity of this directive can help.
Dr. Freeze's favorite thing in the functional world!

Links Mentioned in Today’s Episode:
SmartLogic
Dr. Jim Freeze on Twitter
ElixirConf
Sophie DeBenedetto
Elixir Radar
Phoenix In Action
Geoffrey Lessel
Saša Jurić
Sandi Metz

Special Guest: Dr. Jim Freeze.

Season 3 Trailer

podcast@smartlogic.io (SmartLogic LLC) — Tue, 19 Nov 2019 06:00:00 -0500

Welcome back to Season 3! Our theme this time around is Working with Elixir. Listen for more on our theme, upcoming guests, and our new name.

Season Two Wrap

podcast@smartlogic.io (SmartLogic LLC) — Thu, 03 Oct 2019 06:00:00 -0400

Welcome to the last episode of Season 2 of the podcast! We are taking this opportunity to recap what we covered in the season and talk about what we liked and what we didn't like so much. We do not have a guest for today's show so it is just Eric and Justus doing some reflection. We do want to take this opportunity to thank all of our guests that have appeared on this season and shared their expertise with us, we definitely feel we learned a lot during this time! In Season 3 we will be focussing on functional programming, performance and teaching Elixir, so make sure to keep an eye out for when that drops in the future!

Key Points From This Episode:

The possibility of longer episodes for next season
Reflections on ElixirConf and the time we spent there this year.
The upcoming conference in New Orleans that Eric is keynoting.
Thoughts on the future of the podcast and the promise of Season 3.
Reach out! We want to hear from you!
And much more!

Links Mentioned in Today’s Episode:

SmartLogic — https://www.smartlogic.io
Brooklyn Zelenka — https://github.com/expede
Bryan Joseph — https://github.com/bryanjos
Paul Schoenfelder — https://github.com/bitwalker
Meryl Dakin— https://github.com/meryldakin
René Föhring— https://twitter.com/rrrene
Michal Muskala — https://michal.muskala.eu/
Todd Resudek — https://www.linkedin.com/in/toddresudek/
Shanti Chellaram— https://github.com/shantiii
Sophie DeBenedetto — http://sophiedebenedetto.nyc/
Dave Lucia — https://www.linkedin.com/in/david-lucia-a395441b
ElixirConf — https://elixirconf.com/2019
The Big Elixir — https://www.thebigelixir.com/
Le Petit Theatre — http://www.lepetittheatre.com
Lone Star Elixir — https://www.lonestarelixir.com
The Empire Strikes Back — https://www.rottentomatoes.com/m/empire_strikes_back

Dave Lucia on Rustler – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 26 Sep 2019 06:00:00 -0400

Our guest today on the show is Dave Lucia, who is currently the Vice President of Engineering at SimpleBet. He is here as part of Elixir Internals series, to talk to us and all our listeners about Rustler and the contribution he made to the library! According to our guest, Rustler acts as a bridge between Rust and Elixir and allows users to employ the power of Rust within Elixir and a great example of this can be found in Dave's work at SimpleBet. He explains some of this application and the functionality and improvement it offers and the big difference the machine learning models make to this work. Dave also gives us some background to his work and career, previous employment and early explorations of open-source software. He also shares some great tips for problem-solving and learning and improving at programming in Rust. We unpack some of the biggest challenges that faced the creation of Rustler, notable differences between Rust and Elixir and the technical components of the library that the team created. For all this and then some, join us for this great episode!

Key Points From This Episode:

More about our guest and his current work at SimpleBet.
How Dave got started with Elixir while at Bloomberg.
The interesting and beautiful way in which The Outline used Elixir.
Dave's early forays and experiences with open source software.
Problem finding and solving; Dave's tips to those wanting to improve.
Dave's employers' contribution and allowance for open source projects.
Introducing Rustler and what users can do with it!
The biggest challenges of using multiple languages in the backend.
How Rustler works; the core, the code generator and more.
The most important differences between Rust and Elixir.
Dave's best advice and resources for learning and mastering Rust.
And much more!

Links Mentioned in Today’s Episode:

SmartLogic — https://www.smartlogic.io
Dave Lucia — https://www.linkedin.com/in/david-lucia-a395441b
Rustler — https://github.com/rusterlium/rustler
SimpleBet — https://simplebet.io
Dave Lucia on Twitter — https://twitter.com/davydog187
Dave Lucia Email — dave@simplebet.io
Elixir — https://elixir-lang.org
Python — https://www.python.org
JavaScript — https://www.javascript.com
Rust — https://www.rust-lang.org
Bloomberg — https://www.bloomberg.com
Slack — https://slack.com
Vox Media — https://www.voxmedia.com
The Outline — https://theoutline.com
The Rust Programming Language — https://www.amazon.com/Rust-Programming-Language-Steve-Klabnik/dp/1593278284
Rust Playground — https://play.rust-lang.org
Elm Compiler — https://github.com/elm/compiler

Special Guest: Dave Lucia.

Eric Oestrich on ExVenture – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 19 Sep 2019 06:00:00 -0400

This season on Smart Software Season 2, we are focused on the inner workings of Elixir and the inner workings of popular Elixir libraries, or Elixir internals. Today, I have the pleasure of interviewing my colleague, Eric Oestrich who's responsible for the wildly successful Elixir MUD framework ExVenture.

ExVenture - https://exventure.org/
MUDs - https://en.wikipedia.org/wiki/MUD
Ecto - https://github.com/elixir-ecto/ecto
Eric's Going Multi-Node presentation at ElixirConf - https://www.youtube.com/watch?v=lCUKQnkjajo
The Big Elixir - https://www.thebigelixir.com/
Eric's Prometheus presentation at Lonestar Elixir - https://www.youtube.com/watch?v=ETUD9SaRCjY
Prometheus - https://prometheus.io/
Go - https://golang.org/
Celluloid - https://celluloid.io/
Phoenix - https://phoenixframework.org/
Grapevine - https://grapevine.haus/
Gossip - https://mudcoders.com/gossip-the-mud-chat-network-3156cf24edf/

Learn more about how SmartLogic uses Phoenix and Elixir.

Sophie DeBenedetto on Excrypt and Railway – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 12 Sep 2019 06:00:00 -0400

Welcome to another episode of the podcast everybody! As we continue our journey into Elixir internals in Season 2, we welcome Sophie DeBenedetto to tell us about the two libraries she and the Flatiron School created! We talk about Encrypt and Railway and a bunch of other great stuff from the world of Elixir and open source and Sophie shares so much about why she is particularly excited about things at the moment. She talks about the maturation of the Elixir community and her first and most important open-source experiences before diving into her hopes for the future of these platforms. We also discuss the ins and out of the two libraries and our guest does a fantastic job of explaining their functions and the reasons they were built. Sophie shares the major challenges that faced her and the team in creating them and a whole lot more, so make sure to tune in today for all this great information!

Key Points From This Episode:

A brief introduction to Sophie's career, the Flatiron School and her Elixir work.
Sophie's first experiences with open source, contributing to the Elixir School.
Flatiron's support of open source and their attitude towards the growth of engineers.
Why Elixir and Ruby are such important languages to Sophie and Flatiron.
Sophie's wishes for Elixir and what she wants to see more of in the community.
Introducing Encrypt and Excrypt for Elixir and why Flatiron chose to build them.
The hardest parts of building the library, the challenges of encryption.
Elixir's built-in option parser; convenience and accessing data easily.
The Railway hex package and what it enables users to do.
Breaking down the functions of RabbitMQ for Erlang.
The two things that Sophie is most excited about in the Elixir space right now!
And much more!

Links Mentioned in Today’s Episode:

Sophie DeBenedetto — http://sophiedebenedetto.nyc/
Flatiron School — http://sophiedebenedetto.nyc/
Elixir School — https://elixirschool.com/en/
Encrypt — https://github.com/flatiron-labs/encrypt
Escript — https://hexdocs.pm/mix/master/Mix.Tasks.Escript.Build.html
Ruby — https://www.ruby-lang.org/en/
Kafka — https://kafka.apache.org
Ecto — https://hexdocs.pm/ecto/Ecto.html
Erlang — https://www.erlang.org
RabbitMQ — https://www.rabbitmq.com
Phoenix — https://phoenixframework.org
LiveView — https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real-time-apps-no-need-to-write-javascript
Elixir Conf — https://elixirconf.com/2019

Special Guest: Sophie DeBenedetto.

Shanti Chellaram on Pri-Queue and raft_erl – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 05 Sep 2019 06:00:00 -0400

Today on the show we welcome Shanti Chellaram to talk about a couple of Erlang libraries she has created! We hear from her about Pri-Queue and raft_erl, and her motivation behind making them and some of the things we wishes she did differently! Shanti shares some of her background, early coding experiences, affinity for open source and her current work situation. From there we look at Pri-Queue, the problem it addresses and what a priority queue is. A highlight of the show is Shanti giving the best explanation of a bootstrapped skew binomial heap we have heard before explaining some of the main issues she faced in creating Pri-Queue. We then turn to raft_erl, how she got started with it and her hopes for its future. Throughout the conversation Shanti shares her philosophy towards open source and coding going forward as well as offering advice for newcomers to Erlang. Make you you join us for this fantastic episode!

Key Points From This Episode:

A little bit about Shanti's background and current employment.
Shanti's early experiences and what got her into open source software.
Some coding decisions that Shanti would make differently in retrospect.
The problem that Pri-Queue solves; the dearth of data efficient libraries.
What is a priority queue? Ordering your data with scores.
Shanti explains a bootstrapped skew binomial heap!
Some of the hurdles that Shanti faced in writing Pri-Queue.
How Shanti got started on her other library, raft_erl.
The three Raft protocols and how much of it is implemented in the library.
Shanti's next goals for raft_erl; bug free and widely used.
The importance of distributed systems and Shanti's philosophy looking to the future.
Advice for someone just starting out in Elixir!
And much more!

Links Mentioned in Today’s Episode:

SmartLogic — https://www.smartlogic.io/
Shanti Chellaram Linkedin— https://www.linkedin.com/in/shanti-chellaram-495444187
Shanti Chellaram on Twitter — https://twitter.com/theccoder
Shanti Chellaram on github — https://github.com/shantiii
Erlang — https://www.erlang.org/
Elixir — https://elixir-lang.org/
Pri-Queue — https://github.com/okeuday/pqueue
raft_erl — https://github.com/shantiii/raft_erl
MailChimp — https://mailchimp.com
Teachers Pay Teachers — https://www.teacherspayteachers.com/
Purely Functional Data Structures — https://www.amazon.com/Purely-Functional-Structures-Chris-Okasaki-ebook/dp/B00AKE1V04
Rust — https://www.rust-lang.org/
Raft — https://raft.github.io/
Raspberry Pi — https://www.raspberrypi.org/
ElixirConf — https://elixirconf.com/2019
Partisan — https://partisan.cloud/

Special Guests: Dan Ivovich and Shanti Chellaram.

Michał Muskała on Ecto and jason – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 29 Aug 2019 06:00:00 -0400

Today on the show we are joined by Michal Muskala, who is currently a freelance software engineer and he is here to talk to us about his work on the Ecto and jason libraries. With Ecto we continue our journey into Elixir and Michal explain how he became involved in the project and the work he did on it. He explains a little of its inner workings, issues and what excited him about it initially. We then turn to jason, a widely popular library that Michal created for parsing JSON. Michal unpacks its particulars, differentiating for us between the driver and adapter and the lessons he learned working on them. The last bit of our conversation is spent talking about open source and Michal's commitment to its philosophy. We discuss making time to work on projects, buy in from employers and and why getting involved can be scary yet is so important! For all this and more, join us for this great episode!

Key Points From This Episode:

A little bit about Michal's work background and how he got started on Elixir.
The parts of Ecto that Michal worked on at Google Summer of Code.
Differentiating between the driver and the adapter; communicating with the database.
Structuring the code and what Michal would do differently now.
Creating jason, the default JSON parser and the impetus behind it.
Understanding lexing and tokenizing; largely the same thing with different names.
Macros on jason and forcing the VM to use optimizations in particular cases.
Performance on jason; how Michal achieved the speeds he did.
Michal's path to open source software and what followed his work in MongoDB.
Finding time to work on open source projects while employed.
BEAM, alternative implementations and why they are important.
Michal's call to action for our listeners!
And much more!

Links Mentioned in Today’s Episode:

SmartLogic — https://www.smartlogic.io/
Elixir — https://elixir-lang.org/
Michal Muskala — https://michal.muskala.eu/
Michal Muskala on Twitter — https://twitter.com/michalmuskala?lang=en
Ecto — https://hexdocs.pm/ecto/Ecto.html
jason — https://github.com/michalmuskala/jason
Google Summer of Code — https://summerofcode.withgoogle.com/
MondoDB — https://www.mongodb.com/
Erlang — https://www.erlang.org/
Binary Optimization in Erlang Documentation — https://rhye.org/post/erlang-binary-matching-performance/ (Please verify link)
BEAM — https://blog.stenmans.org/theBeamBook/
Erjang — https://jaxenter.com/introducing-erjang-erlang-for-the-jvm-108005.html
Atom VM — http://atomvm.sourceforge.net/

Special Guest: Michał Muskała.

Todd Resudek on Hex – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 22 Aug 2019 06:00:00 -0400

Today on the show we get stuck into the inner workings of Hex 1.0 and are happy to be joined by returning guest, Todd Resudek. As you might already know, Todd is the Senior Software Engineer at Weedmaps, a regular speaker on the conference scene, and one of the three core team members at Hex. With the total downloads sitting at 641 million, the Hex community is growing rapidly and shows no signs of slowing down. In this episode, we discover what makes the Hex packages some of the most popular packages out there today, as well as the new and improved features currently in the pipeline. In addition, we find out how Todd first got involved with the Hex team and how the team makes decisions and problem solves.

Key Points From This Episode:

Transferring a new library into an old ecosystem.
Todd’s challenges learning Elixir and Hex.
Learn more about the functions of Alphabetify.
An introduction to the uses of ETS storage.
Contributing to Open Source while working at Weedmaps.
Discover how Todd got involved with the Hex team.
Learn more about the different faces of Hex.
Find out how decisions are made within the Hex team.
Just how busy is the Hex community right now?
The top five underground features of Hex.
Discover the latest features now available on Hex.
Find out what new Hex features are in the pipeline.
And much more!

Links Mentioned in Today’s Episode:

Todd Resudek — https://www.linkedin.com/in/toddresudek/
Weedmaps — https://weedmaps.com/
Hex — https://hex.pm/
rebar3 — https://www.rebar3.org/
Alphabetify — https://hex.pm/packages/alphabetify
ETS — https://elixirschool.com/en/lessons/specifics/ets/
Elixir Mix Podcast — https://devchat.tv/elixir-mix/
Voitek — https://voitekk.com/
Erlef Erlang Ecosystem Foundation — https://erlef.org/
Crates — https://crates.io/crates/hex
Smart Software with SmartLogic — https://podcast.smartlogic.io/
Nerves MeetUp on Twitter — https://twitter.com/nervesmeetup
The Big Elixir — https://www.thebigelixir.com/

Special Guest: Todd Resudek.

Chris Keathley on Wallaby and Raft – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 15 Aug 2019 06:00:00 -0400

In this episode of the podcast we are joined by Chris Keathley to continue our exploration of Elixir internals as he tells us about two very popular libraries that he developed, Wallaby and Raft. We start off with some background and his initial experiences with Elixir and open source projects before diving into Wallaby and some of the biggest lessons that Chris learned during and after his work on the library.

Chris does a great job of explaining concurrent tests and the Sandbox and some of the reasons he has pretty much stopped working on the front end of projects. From there we move onto another one of Chris' exciting projects, Raft! In order to introduce the library, Chris explains more about consensus algorithms, Leslie Lamport and his groundbreaking work on Paxos. Raft is, in some ways, a simplified, more accessible version of Paxos for Elixir and Chris goes on to give a brief rundown of its inner workings. For this great conversation with a great guest, join us today!

Key Points From This Episode:

Chris' background, history with Elixir and his current employment.
How Chris got started with open source work.
Why Chris has moved away from front end work in the last while.
The major lessons Chris learned while building Wallaby.
How the concurrent tests work on Wallaby and the Sandbox.
Why Chris is still excited about Raft, even though he hasn't touched it in a while.
Explaining Raft, consensus algorithms and Paxos.
How the Raft library actually works; building Raft systems and processes.
Where to find and connect with Chris online!
And much more!

Links Mentioned in Today’s Episode:

SmartLogic — https://www.smartlogic.io/
Chris Keathley — https://keathley.io/
Chris Keathley on github — https://github.com/keathley
Bleacher Report — https://bleacherreport.com/
Wallaby — https://hexdocs.pm/wallaby/Wallaby.html
Raft — https://raft.github.io/
Erlang — https://www.erlang.org/
Slack — https://slack.com/
Leslie Lamport — http://www.lamport.org/
Paxos Made Live — https://blog.acolyer.org/2015/03/05/paxos-made-live/
Elixir Outlaws Podcast — https://elixiroutlaws.com/

Special Guest: Chris Keathley.

René Föhring on Credo – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 08 Aug 2019 06:00:00 -0400

Welcome back to the SmartLogic Podcast where we talk about the latest developments and best practices in the web and mobile software industry. In continuing with our theme of Elixir Internals, we’re having a conversation about the inner workings of one of the most popular Elixir libraries, Credo, and we are joined by the author René Föhring.

René shares the story of how he was introduced to Elixir while doing his PhD and looking for a new programming language and then shares the philosophy and inspiration Credo was developed on. Wanting Credo to be a less rule-based, authoritative code analysis tool and more user friendly, René focused on creating it to act as a type of digital mentor to the many developers out there who do not have a human mentor. He also shares about some of the launching hiccups, what he would have done differently had he been given another opportunity and some of the most important lessons that he has learned working in the open source community. Be sure to join us for all the inside info!

Key Points from This Episode:

More about René’s job as head of product development at 5 Minds and what they do.
What he does in his free time: open source maintenance and conference speaking.
How he got started with Elixir and wanting to learn a new programming language.
What Credo is all about, why you’d want to use it and what makes it different.
The inspiration behind writing Credo and wanting a more positive, less dogmatic tool.
Starting off building on Dogma but then pivoting and going in an independent direction.
The hiccups René experienced when first releasing Credo and what he’d do differently.
The different checks in Credo and how they function and respond to issues.
How Elixir 1.6 impacted the development of Credo.
What’s new with the Credo 1.1 release?
René’s experience working with open source and the first library he contributed to.
Important lessons he has learned by being part of the open source community.
And much more!

Links Mentioned in Today’s Episode:

Elixir — https://elixir-lang.org/
Credo — http://credo-ci.org/
René Föhring on Twitter — https://twitter.com/rrrene?lang=en
5 Minds IT – Solutions — https://www.5minds.de/
GitHub — https://github.com/
Ruby — https://www.ruby-lang.org/en/
Go — https://golang.org/
Cplusplus — http://www.cplusplus.com/
StyleCop — https://github.com/StyleCop/StyleCop
Dogma — https://github.com/lpil/dogma
Hex — https://hex.pm/

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: René Föhring.

Meryl Dakin on Token Alchemist – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 01 Aug 2019 06:00:00 -0400

Today on the show we continue our series on the inner workings of several different Elixir libraries and are happy to be joined by Meryl Dakin, Software Engineer at the Flatiron School and author of Token Alchemist. In this episode, we discover how Meryl got started with Elixir and what the process was like for her transitioning from Ruby to Elixir. We learn more about the internal functions of Token Alchemist within the school context and discuss the unique opportunities Meryl has discovered in Elixir, as well as the trickier language features that programmers are likely to experience in their learning process. Meryl also shares the challenges that Token Alchemist attempts to overcome – delving deeper into LTI, the Learn.co platform, OAuth and JSON. For all this and more, be sure to click play!

Key Points From This Episode:

Discover why Meryl first got started with Elixir.
Learn more about the Flatiron Bootcamp for coders.
Meryl’s experience in transitioning from Ruby to Elixir.
The opportunities for concurrency and fault tolerance in Elixir.
Discover the top three tricky language features in Elixir.
The benefits of going back to the basics of Elixir.
Find out the problems that Token Alchemist attempts to solve.
Meryl explains LTI and the Learn.co platform for students.
Learn more about custom parameters in Token Alchemist.
The process of learning OAuth in Token Alchemist.
What to consider when using LTI in Elixir.
The benefits of resource link history ID’s in the LTI spec.
Opportunities for you with Token Alchemist.
And much more!

Links Mentioned in Today’s Episode:

We Work — https://www.wework.com/
Flatiron School — https://flatironschool.com/
Elixir — https://elixir-lang.org/
Ruby — https://www.ruby-lang.org/en/
Learn.co — https://learn.co/
Meryl on LinkedIn — https://www.linkedin.com/in/meryldakin/
Meryl on Twitter — https://twitter.com/meryldakin
Meryl on GitHub — https://github.com/meryldakin
Token Alchemist on GitHub — https://github.com/meryldakin/token_alchemist

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Meryl Dakin.

Paul Schoenfelder on Distillery – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 25 Jul 2019 06:00:00 -0400

Welcome back to show everyone and today in our exploration of Elixir libraries we are talking to Paul Schoenfelder! He is here to unpack Distillery, his own creation from the world of Elixir and tell us about how it works. We also discuss how Paul made the transition from bigger corporations into the startup world, his early experiences of different coding languages and the initial steps he took in writing Distillery. Paul is very honest about the unclear future of the library and he shares his hopes for it for the short term as well as clarifying its key concepts and functions. He gives great advice and directions for learning more about the resource and how you can help him and his projects out if you use them. For all this and then some, be sure to join us today for the show!

Key Points From This Episode:

Paul's work background, language history and the last few years working Elixir.
The first library that Paul contributed to and created on his own!
What brought about the creation of Distillery.
Clarifying releases, compiling, generating, deployment and more.
Where to learn more and find out details about the library.
The first steps Paul took when writing this latest version of the Distillery.
Looking to the future of Distillery and its current best use cases.
Hot upgrades and who they can be useful to when it comes to Elixir.
Let Paul know if you are using or want to contribute to a project of his!
And much more!

Links Mentioned in Today’s Episode:
Smartlogic — https://www.smartlogic.io/
Paul Schoenfelder — https://github.com/bitwalker
Bitwalker — http://bitwalker.org/
Distillery — https://hex.pm/packages/distillery
DockYard — https://dockyard.com/
Erlang — https://www.erlang.org/
Phoenix — https://phoenixframework.org/

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Paul Schoenfelder.

Bryan Joseph on ElixirScript – Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 18 Jul 2019 06:00:00 -0400

Today on the show we continue our series on the inner workings and various libraries of Elixir and are very happy to welcome Bryan Joseph of Revelry to talk about his very own ElixirScript. ElixirScript is essentially an Elixir to JavaScript compiler, allowing users to run Elixir online more easily. We ask Bryan what inspired this project and about some of the major challenges that have faced it. We also talk about the role of his company, Revelry in his career and work in open source. Bryan tells us about his very own conference, The Big Elixir and why you should be traveling to New Orleans to check it out! Other topics covered include the architecture of ElixirScript, binary pattern matching, Bryan's other experiences of libraries and his hopes for ElixirScript's future. For all this and then some, be sure to listen in today!

Key Points From This Episode:

Some background on Bryan, his work and how he got started with Elixir.
What is ElixirScript? What does it do? How Brian got the idea!
ElixirScript's architecture; the inner workings of the compiler.
The major problems and challenges that face this task with JavaScript.
Step one in the process; the conversion of concepts.
Binary pattern matching and the implementation of strings.
The things Bryan would do differently looking back on the product.
Bryan's other experiences of libraries, contributions and fixes.
Marketing, posting and getting the word out on ElixirScript.
The current state of the project and hopes for the future.
A little bit about The Big Elixir and what sets it apart from other conferences.
And much more!

Links Mentioned in Today’s Episode:

Smartlogic — https://www.smartlogic.io/
ElixirScript — https://elixirscript.github.io/
Bryan Joseph — https://github.com/bryanjos
Revelry — https://revelry.co/
The Big Elixir— https://www.thebigelixir.com/
Metaprogramming Elixir — https://www.amazon.com/Metaprogramming-Elixir-Write-Less-Code/dp/1680500414
Chris McCord — http://chrismccord.com/
Erlang — https://www.erlang.org/
ElixirCon — https://www.elixirlabs.net/events/elixircon-2018
Lonestar Elixir — https://www.lonestarelixir.com/
Operation Spark — https://operationspark.org/
Flatiron — https://flatironschool.com/

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Bryan Joseph.

Brooklyn Zelenka on Witchcraft - Elixir Internals

podcast@smartlogic.io (SmartLogic LLC) — Thu, 11 Jul 2019 06:00:00 -0400

Hey everybody and welcome back to Season 2 of the podcast! This season we will be talking about Elixir internals, libraries and the inner workings of the language. In our first episode we are very happy to be joined by Brooklyn Zelenka to start off our journey on the subject with an exploration of her very own Witchcraft.

In this episode we talk to Brooklyn about her history with Elixir, how she got started and what attracts her to it. Brooklyn explains the influence that open source philosophy has had on her career in developing and from there she gives a pretty comprehensive introduction to what Witchcraft is, expanding its key concepts. Although this is quite a high level discussion about Elixir and Witchcraft, we are confident that with Brooklyn's expert help even our most uninitiated listener can get some benefit from our conversation. We also talk about type systems, property-based checking and Dialyzer, so for all of this and more make sure to join us as we kick things off for Season 2!

Key Points From This Episode:

A quick introduction to Brooklyn, where she works and how she got started with Elixir.
The influence of open source and library contributions on Brooklyn's development.
Getting to grips with Witchcraft; defining monads and functors.
Why some of these scary terms do not need to frighten you.
A few little things that differentiate Witchcraft and some surprising elements.
The convenient guarantees that Witchcraft provides around your data structure.
Why there is no type system baked into Elixir; overheads, inputs and outputs.
Property-based checking and compile times in Witchcraft.
Merging of Elixir and Dialyzer; benefits and problems.
Getting in touch with Brooklyn and getting involved with Witchcraft and Elixir.
And much more!

Links Mentioned in Today’s Episode:

Smartlogic — https://www.smartlogic.io/
Brooklyn Zelenka — https://github.com/expede
Brooklyn Zelenka on Twitter — https://twitter.com/expede
Brooklyn Zelenka Email — hello@brooklynzelenka.com
Fission — https://fission.codes/
Elixir — https://elixir-lang.org/
Witchcraft — https://hex.pm/packages/witchcraft
Dialyzer — https://github.com/jeremyjh/dialyxir

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Brooklyn Zelenka.

Season 2 Trailer

podcast@smartlogic.io (SmartLogic LLC) — Tue, 09 Jul 2019 06:00:00 -0400

We’re excited to announce our season two topic, Elixir Internals. In this season we talk with developers behind some of the most popular Elixir libraries, including Witchcraft, ElixirScript, Distillery, Ecto, and more!

Elixir in Production Recap

podcast@smartlogic.io (SmartLogic LLC) — Thu, 18 Apr 2019 06:00:00 -0400

With this season over, we bring Dan Ivovich back to talk about what we learned.

Dan Ivovich - Director of Development Operations @ SmartLogic

00:43 - Why are you using Elixir in production?
01:20 - Advantages / disadvantages of Elixir
02:38 - How do you deploy?
03:48 - Zero downtime deploys
05:40 - Clustering
06:56 - Elixir App performance
09:00 - Background task processing
10:36 - Common Libraries
14:40 - 3rd Party Services
16:16 - Do you have a story where Elixir saved the day in production?
17:56 - OTP features
18:31 - Tip to developers

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Dan Ivovich.

Jeffrey Matthias from Community - Elixir in Production

podcast@smartlogic.io (SmartLogic LLC) — Thu, 11 Apr 2019 06:00:00 -0400

We talk with Jeffrey Matthias from Community about their current and past Elixir projects and how they are deployed.

Jeffrey Matthias - Community

Find Jeffrey elsewhere online:
http://github.com/idlehands
https://twitter.com/idlehands

0:47 - Give us a quick overview of the Elixir projects you have in production.

3:29 - Why are you using Elixir in production?

6:04 - What are some of the high level advantages / disadvantages of Elixir, from your perspective?

10:14 - What do you use to host your Elixir app?

Linode, AWS, DO
Heroku
Enmesos
mesos

How do you deploy your application?

Ansible
Deploy scripts
Distillery

14:19 - Are you able to get zero downtime deploys?

If so, how?

17:06 - Do you cluster the application?

If so, how?

22:53 - How does your Elixir App perform compared to others in your environment?

Response time
Throughput
Jobs/hr

25:01 - How are you solving background task processing?

29:17 - What libraries are you using?

Phoenix

33:53 - Third party apps

37:28 - Do you have a story where Elixir saved the day in production?

40:42 - If you could give one tip to developers out there who are or may soon be running Elixir in production, what would it be?

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Jeffrey Matthias.

Links:

Jay Ashe from Cava - Elixir in Production

podcast@smartlogic.io (SmartLogic LLC) — Thu, 04 Apr 2019 06:00:00 -0400

We talk with Jay Ashe from Cava about their current and past Elixir projects and how they are deployed.

Jay Ashe - Cava

Find Jay elsewhere online:
https://twitter.com/jgashe

0:40 - Give us a quick overview of the Elixir projects you have in production.

CAVA is a fast-casual mediterranean restaurant chain with 75 stores across the US. Elixir and phoenix power CAVA’s online ordering platform (order.cava.com and the CAVA app). We’ve got a REST (and websockets) api sitting behind react and our mobile apps, and we use phoenix templates for some of our back of house systems.

1:11 - Why are you using Elixir in production?

We have from the start! The application was originally implemented by Chris Bell and his team at madebymany. Chris, by the way, has a fantastic talk from ElixirConf 2016 that goes into our architecture and how we use elixir and OTP constructs to model our business logic. Chris will occasionally talk about the CAVA project on his Elixir podcast, ElixirTalk.

Chris’ Talk - https://www.youtube.com/watch?v=fkDhU-2NWJ8

1:58 - What are some of the high level advantages / disadvantages of Elixir, from your perspective?

Advantages: Elixir and Phoenix gives you rails-esque productivity/developer experience that scales. I think phoenix channels are a great example of this. Build a channel with complex real-time functionality and let it scale effortlessly.

Disadvantages:

Hiring and onboarding, depending on your mindset, can be difficult. If you’re used to hiring for experience in your stack, its just going to be more difficult. Lately we’ve started doing one-hour weekly knowledge shares that cover elixir basics and are closely tied to our usage of them. So, here’s a test case, and here are all of the test helpers that we have set up that will help you write that test. We also just sent a new Elixir dev to lonestar elixir

3:59 - What do you use to host your Elixir app?

Heroku
How do you deploy your application?
- Heroku-buildpack-elixir https://github.com/HashNuke/heroku-buildpack-elixir

4:44 - Are you able to get zero downtime deploys?

As close as possible! We get that out of the box with heroku. When we deploy, heroku won’t point traffic to the new dyno until the app is healthy. We make extensive use of Phoenix channels over websockets, and our clients will reconnect automatically and transparently.

5:10 - Do you cluster the application?

Nope.

5:52 - How does your Elixir App perform compared to others in your environment?

I can’t really talk about numbers here, but Elixir is not at all our bottleneck. We don’t have other production applications

6:25 - How are you solving background task processing?

Quantum for cron jobs, genservers for everything else. We’re running a single elixir application that handles all synchronous and async processing

7:07 - What libraries are you using?

Phoenix
Phoenix_swagger for API documentation that integrates with controller tests https://github.com/xerions/phoenix_swagger
Ex_rated for rate limiting calls to our integrations https://github.com/grempe/ex_rated
Timex and calendar for datetime support with timezones https://github.com/bitwalker/timex
A combination of httpotion and httpoison for HTTP clients, but im interested in trying Mint https://github.com/ericmj/mint https://github.com/appcues/mojito
Bamboo for transactional emails, like order confirmations etc https://github.com/thoughtbot/bamboo

8:59 - 3rd Party Services (i.e. Email, Payment Processing, etc)

Sendgrid for email, Google for geocoding, slack for some internal alerting of application health, LevelUp for payments. https://www.thelevelup.com/

10:07 - Do you have a story where Elixir saved the day in production?

Yes and no. So I could tell this story by explaining the issue we saw and the underlying cause at the same time, but I think it would be more fun to tell it like our team experienced it.
One day at lunch our application started going down. Lots of 500 errors. Red lights flashing. Panic ensuing. Lunch is our busiest time of day, so 1) we thought it was load related and 2) we really needed to fix it
None of our traditional resources (database, cpu, memory) were constrained and our integrations that were synchronous were fine.
Our logs were littered with errors from an analytics integration that ran asynchronously on genservers, but it didn’t seem related because we could see the error logs at times when our application was otherwise healthy. The team that used the analytics didn’t have a pressing need for them, and we deprioritized fixing the issue because the bug we were working on was so much more important (that’s foreshadowing).
I spent a little time looking at websockets, but I was easily able to match the load of the websocket portion of our application on my local machine with no degradations in performance (thanks, phoenix), so that was out.
At this point the issue was going on every day at lunch and I was getting annoyed at seeing the logs from the analytics integration when debugging, so I spent like 15 minutes finding and fixing the issue (a bad API key, basically)
Voila, issue gone. Time to grab some lunch.
We spent a while coming up with an explanation for this. Eventually we learned about max_restarts on a supervisor. By default, if a process crashes 3 times in 5 seconds, the process won’t be restarted again. So if another process (like the one handling a web request) tries to call that process that wasn’t restarted, the caller would crash, and we’d start to get 500 errors, customers couldn’t log in, mass confusion.
So there are a few takeaways from this story: For a while, elixir saved the day in production.
- A supervision tree prevented failures from the analytics process from affecting customers, until the scale of our failures exceeded the max_restart level.
- Our supervision tree needed some love though, clearly. - Monitor your resources. CPU is a resource, but calls to another API are also a resource and can get unhealthy too.

15:00 - Are you using any cool OTP features?

GenServers, definitely. There’s lots we can do asynchronously especially in terms of our integrations. One process per store is a cool model that scales well and keeps issues isolated to a single store.

15:50 - If you could give one tip to developers out there who are or may soon be running Elixir in production, what would it be?

If you’re on a small team, Heroku or a similar provider might give you a lot of value in terms of infrastructure you can set up and forget.

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Jay Ashe.

Links:

Frank Hunleth - Elixir in Production

podcast@smartlogic.io (SmartLogic LLC) — Thu, 28 Mar 2019 06:00:00 -0400

We talk with Frank Hunleth from the Nerves core team about their current and past Elixir projects and how they are deployed.

Frank Hunleth - Nerves

Find Frank elsewhere online:
https://twitter.com/fhunleth
https://github.com/fhunleth

0:53 Frank intro
2:02 Give us a quick overview of the Elixir projects you have in production.
4:25 Why are you using Elixir in production?
8:00 What are some of the high level advantages / disadvantages of Elixir, from your perspective?
9:25 What hardware do you deploy to?
12:05 How do you get code to hardware after deployment?
13:47 How do you secure the code?
18:12 Do you cluster?
If so, how?
How does your Elixir App perform compared to others in your environment?
22:45 How does Elixir compare to other languages?
26:15 More information about Nerves

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Frank Hunleth.

Links:

Mark Ericksen - Elixir in Production

podcast@smartlogic.io (SmartLogic LLC) — Thu, 21 Mar 2019 06:00:00 -0400

We talk with Mark Ericksen from Elixir Mix about their current and past Elixir projects and how they are deployed.

Mark Ericksen - Elixir Mix

Find Mark elsewhere online:
https://twitter.com/brainlid
https://brainlid.org/

00:32 Intro
0:58 Mark intro
Developing a long time. C#, then Rails. Webforms were terrible. Rails is “Wow, this is how web development should be… I moved across the country to work with this technology”
The Rails Community is strong. Dave Thomas got Mark into Elixir

2:48 What Elixir projects do you have in production?
A Rails app and a number of Elixir Micro-liths

4:29 Why do you use Elixir

6:45 Trends in moving from Ruby and Rails to Elixir
Ruby Syntax
Pattern Matching
Concurrency primitives
Fault Tolerance and a functional paradigm
Erlang/OTP

6:48 Comparing Elixir community to Ruby community to C# community

8:27 Any disadvantages to using Elixir?
Building releases. Configuring releases.
mix.release

10:13 Where are you hosting these bad boys?
AWS
Kubernetes in Production. So Fresh.
Docker and Distillery 2.0 Releases
Yaml files and Bash Scripts
Makefiles

10:53 What else are you using besides docker

12:36 Helm and Ksonnet.

13:55 Deploys

14:39 Clustering

17:50 How do your Elixir apps compare to the Ruby apps?
Big Elixir Apps

20:00 How Mark handles background jobs
Easy to write yourself with BEAM primitives

21:27 Libraries - Quantum, Bamboo, ex_machina, prometheus_ex via Eric’s influence

23:29 Third party integrations. Major ones were easy. Banks were bad.
Literally had to FTP files. Had to use java to write xml spreadsheets. The horror.

25:26 Has Elixir ever saved the day for you in Production?

29:42: Cool OTP features
30:57 Tips to developers
35:36 Where to find Mark

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Mark Ericksen.

Links:

Brooklyn Zelenka from SPADE Co. - Elixir in Production

podcast@smartlogic.io (SmartLogic LLC) — Thu, 14 Mar 2019 06:00:00 -0400

We talk with Brooklyn Zelenka from SPADE Co. about their current and past Elixir projects and how they are deployed.

Brooklyn Zelenka - SPADE Co.

Find Brooklyn elsewhere online:
https://twitter.com/expede
https://github.com/expede

1:08 - Brooklyn’s Background

Brooklyn's background and experience with Elixir is deep. Huge open source contributor.
Got started in Elixir just after Phoenix got to 1.0.

1:53 - Worked on several Elixir projects in production.

2:43 - Why she got into Elixir.

Real Time
More performant than Rails.
Great documentation
Industrial-grade

4:38 - When you wouldn't use Elixir.

Easy to get stakeholder buy-in. Just point to WhatsApp.

Elixir is made for 2019
CLI tools
Repl-driven development
TDD tools built in by default

All the best practices we have today are built in.

7:14 - Where has Brooklyn hosted her apps?

Heroku for POC's. AWS for production. Dockerized because "kubernetes is the new hotness"

9:40 - Do you do any clustering?

Load balanced above. AWS load balancing is very standard. They're well understood and have a nice developer experience.

10:29 Are you able to get any zero downtime deploys?
Zero downtime deploys. Awesome but impractical. Rolling deploys are easier and usually more appropriate. Some requirements make it valuable.

Erlang error states. Exceptional. Allows you to build for the happy path. Don't worry about error handling all the time.

Witchcraft and dark magic. Monads.

Poke around the standard library.

12:50 - How does Elixir compare to Rails in terms of response times, and other aspects?

15:32 - What libraries do you use and what have you built?

22:41 - Any cool features of OTP you are using?

25:36 - One tip to developers new to Elixir

Build up a peer-to-peer cli chat from scratch in one GenServer.

Find her at @expede everywhere on the internet.

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Brooklyn Zelenka.

Links:

Todd Resudek from Weedmaps - Elixir in Production

podcast@smartlogic.io (SmartLogic LLC) — Thu, 07 Mar 2019 06:00:00 -0500

We talk with Todd Resudek from Weedmaps about their current Elixir projects and how they are deployed.

Todd Resudek - Weedmaps

Find Todd elsewhere online:
https://twitter.com/sprsmpl
https://github.com/supersimple

00:00 - Intro
01:06 - Tom introduces himself
02:54 - What is Weedmaps?
04:33 - Overview of the Elixir projects you have in production.
06:25 - Why are you using Elixir in production?
07:21 - Advantages / disadvantages of Elixir
10:37 - What do you use to host your Elixir app?
10:50 - How do you deploy your application?
11:22 - Are you able to get zero downtime deploys?
12:00 - Do you cluster the application?
13:00 - How does your Elixir App perform compared to others in your environment?
14:15 - How are you solving background task processing?
16:40 - What libraries are you using?
21:09 - 3rd Party Services
23:56 - Do you have a story where Elixir saved the day in production?
24:22 - Are you using any cool OTP features?
24:39 - Tip to developers
25:12 - Where you can find him
25:32 - Outro

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Todd Resudek.

Links:

Lonestar ElixirConf 2019 Lunchisode

podcast@smartlogic.io (SmartLogic LLC) — Wed, 06 Mar 2019 03:15:00 -0500

We sat down with numerous developers, including José Valim and Chris McCord, during the Saturday lunch at Lonestar ElixirConf 2019. Hear what they had to say about the state of Elixir!

Guests:
José Valim - Creator of Elixir
Chris McCord - Creator of Phoenix
Paul Schoenfelder - Creator of Distillery, Timex, Libcluster, and many others
Chris Keathley - Host of Elixir Outlaws, developer at Bleacher Report
Amos King - Host of Elixir Outlaws
Jim Freeze - Organizer of ElixirConf, ElixirConf EU, and others
Susumu Yamazaki - Creator of Hastega
Brian Cardarella - CEO of Dockyard
Osa Gaius - Engineer at Mailchimp

Spectating:
Bruce Tate and Ben Marx

00:00 - Intro
01:47 - LoneStar begins
02:03 - Panelists introduce themselves
09:15 - Where is Elixir going?
10:14 - Releases
19:04 - The issue with hype
26:30 - Osa Intro
29:00 - Define lists
40:00 - How can Elixir displace Java?

Learn more about how SmartLogic uses Phoenix and Elixir.

Ryan Billingsley from ClusterTruck - Elixir in Production

podcast@smartlogic.io (SmartLogic LLC) — Thu, 28 Feb 2019 06:15:00 -0500

We talk with Ryan Billingsley from ClusterTruck about their current Elixir projects and how they are deployed.

Ryan Billingsley - ClusterTruck

Find Ryan elsewhere online:
https://twitter.com/ryanbillingsley
https://horriblenight.com/

00:00 - Fade In
00:50 - Ryan introduces us to ClusterTruck.
02:00 - How did Ryan get into Elixir?
03:12 - Where does the name ClusterTruck come from?
04:17 - Tell us about the projects you have in production.
05:50 - Why are you using Elixir in these projects.
08:11 - Disadvantages of using Elixir
09:22 - Comparing Elixir with Ruby, Node, Go.
11:38 - Where is ClusterTruck hosting their applications?
15:03 - Kubernetes?
16:03 - Zero Downtime Deployments?
16:42 - Do you do any clustering?
18:06 - How does Elixir perform compared to other project environments you’ve worked in?
19:52 - How are you solving background task processing?
21:09 - Other libraries?
23:34 - Other third party integrations?
25:46 - Is there a time Elixir has saved the day in Production?
27:47 - Cool OTP Features!
29:45 - Tips to devs thinking about running Elixir in Production.
31:17 - Outro

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Ryan Billingsley.

Links:

Dan Ivovich from SmartLogic - Elixir in Production

podcast@smartlogic.io (SmartLogic LLC) — Thu, 28 Feb 2019 06:00:00 -0500

We talk with developers from the team here at SmartLogic about our current practices on deploying Elixir and Phoenix in production.

Dan Ivovich - Director of Development Operations @ SmartLogic

Learn more about how SmartLogic uses Phoenix and Elixir.

00:00 - Fade In

00:30 - Introductions to Eric, Dan and SmartLogic

Dan Ivovich - Director of Development Operations @ SmartLogic

Eric Oestrich - Developer, Elixir Lead @ SmartLogic

Justus Eapen - Full stack developer @ SmartLogic

Introduced to Elixir by an old colleague.

1:20 - What Elixir projects do you have in production?

Several client projects in production. Several Mobile Apps with APIs powered by Phoenix and Elixir.

Baltimore Water Taxi.

A digital marketplace.

And more!

1:57 - Advantages and disadvantages to using Elixir.

We made the switch when a colleague was stoked about Functional Programming and introduced us to Elixir. We were won over by the performance and rich feature sets, OTP, etc.

2:43 - Where are we hosting our Elixir Apps?

Heroku
AWS
Linode
Digital Ocean

6:20Deployment process, tools, scripting

Ansible - for underlying VPS’s, servers, and more recently deployment itself. (Similar to Capistrano).
Distillery
Mix.release

7:18 - Zero Downtime Deployments

Old school load balancers and rolling restarts

7:46 - What are the performance metrics like? Comparatively.

Ruby ends up with memory leaks. That doesn’t happen with Elixir.
Memory utilization is flat and low no matter what.
“Phenomenal response times”

8:54 - How does Eric think about clustered applications in Elixir?

Going Multi Node (https://www.youtube.com/watch?v=lCUKQnkjajo)
Pg2 - process groups
Mnesia distributed database (beware!)
“Just sending messages to pids because Erlang is great”
Swarm / Horde

12:40 - How do we handle background tasks?

Started with verk
Recently becoming more comfortable with spinning up GenServers
“The language itself is built to be concurrent.”

15:06 What libraries are we using in prod?

First thing: You don’t need a whole lot because the language is so well designed.
Phoenix - web framework
Ecto - sort of an ORM
Distillery - for releases
Bamboo - for sending emails
Quantum - for task scheduling
Timex - for dates and times, and timezones
Cachex - for caching

18:20- What third party integrations have we attempted

Stripe
Square
Twilio
Mindbody

Always building our own clients. Using HTTPoison

19:58Has Elixir ever saved the day in production?

It’s saved many days by PREVENTING ISSUES. Systems are architected for reliability and fault-tolerance.

21:48 - Where do supervision trees come from? What is OTP?

OTP is an Erlang standard lib
Includes supervision trees, genservers, ETS, and a lot of stuff we don’t even know about!
gen_tcp
Mnesia
dets

23:43- Tips for devs considering running elixir in production.

Jump in and read the docs
Understand how systems boot, distillery releases, config providers, etc.
“Good server monitoring hygiene”
“DIVE IN!” 19:54 Outro

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Dan Ivovich.

Links:

Smart Software Season 1 Trailer

podcast@smartlogic.io (SmartLogic LLC) — Mon, 25 Feb 2019 10:00:00 -0500

Welcome to the first season of Smart Software with SmartLogic. We'll be interviewing several companies about how they use Elixir in Production this season. In this preview episode, we introduce ourselves and some of the topics we’ll be covering.

Learn more about how SmartLogic uses Phoenix and Elixir.