Afleveringen
-
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/phoenixliveview/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://www.youtube.com/watch?v=mrpQHZcy3CI)
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 (https://www.youtube.com/watch?v=u2WciH6rAFg) - Theo’s video
Phoenix LiveView Is Making Me Reconsider React... (https://youtu.be/aOk67eT3fpg?si=MTxtIv-xmuJZYbup)- Theo’s other video
Podcast: Thinking Elixir 206: BeamOps - DevOps on the BEAM (https://podcast.thinkingelixir.com/206) Special Guests: David Bernheisel and Mark Ericksen. -
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 [email protected]
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. -
Zijn er afleveringen die ontbreken?
-
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/phoenixliveview/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. -
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. -
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/dnscluster
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/promex/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/ -
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. -
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. -
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/fileuploads.html
https://hexdocs.pm/phoenixlive_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/ -
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. -
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. -
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: [email protected]
What is a PRD? https://en.wikipedia.org/wiki/Productrequirementsdocument Special Guests: Alicia Brindisi and Bri LaVorgna. -
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/unx5AIvSdc
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/exunit/ExUnit.html
Code-Level Testing of Smalltalk Applications https://www.cs.ubc.ca/~murphy/stworkshop/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/ectosql/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. -
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/roclang
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/Softwaretransactional_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. -
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/mixaudit
NimbleTOTP Library for 2FA https://hexdocs.pm/nimbletotp/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. -
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
Links mentioned in this episode:
https://www.womenwhocode.com/network/dc
https://syntax.fm/
https://levelup.video/
https://devopsdays.org/
https://github.com/sveltejs
https://github.com/womenwhocodedc
https://twitter.com/womenwhocode
https://www.remoteworkcalc.com/
https://twitter.com/WomenWhoCodeDC
https://www.meetup.com/dc-elixir/ Special Guests: Camille Clayton and Scott Tolinski. -
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 (https://xiangji.me/2023/12/18/comparing-the-actor-model-and-csp-with-elixir-and-clojure/) Blog Post by Xiang Ji
Comparing the Actor model & CSP concurrency with Elixir & Clojure (https://www.youtube.com/watch?v=lIQCQKPRNCI) 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 (https://pragprog.com/titles/pb7con/seven-concurrency-models-in-seven-weeks/)by Paul Butcher
Seven Languages in Seven Weeks (https://pragprog.com/titles/btlang/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 (https://pragprog.com/titles/btlang/seven-languages-in-seven-weeks/) by Saša Jurić
Redis https://github.com/redis/redis
Designing for Scalability with Erlang/OTP (https://www.oreilly.com/library/view/designing-for-scalability/9781449361556/) by Francesco Cesarini & Steve Vinoski
Discord Blog: Using Rust to Scale Elixir for 11 Million Concurrent Users (https://discord.com/blog/using-rust-to-scale-elixir-for-11-million-concurrent-users)
Xiang's website https://xiangji.me/
Feeling Good: The New Mood Therapy (https://www.thriftbooks.com/w/feeling-good-the-new-mood-therapy-by-david-d-burns/250046/?resultid=7691fb71-d8f9-4435-a7a3-db3441d2272b#edition=2377541&idiq=3913925) by David D. Burns Special Guests: Nathan Hessler and Xiang Ji. -
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=recentdownloads
https://github.com/doorgan/sourceror
https://github.com/rrrene/credo/blob/master/lib/credo/check/readability/largenumbers.ex Special Guests: Marc-André Lafortune and René Föhring. -
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 (https://smartlogic.io/)
Dan’s LinkedIn (https://www.linkedin.com/in/divovich/)
Owen’s LinkedIn (https://www.linkedin.com/in/owen-bickford-8b6b1523a/)
Ruby https://www.ruby-lang.org/en/
Rails https://rubyonrails.org/
Sams Teach Yourself Ruby in 21 Days (https://www.overdrive.com/media/56304/sams-teach-yourself-ruby-in-21-days)
Learn Ruby in 7 Days (https://www.thriftbooks.com/w/learn-ruby-in-7-days---color-print---ruby-tutorial-for-guaranteed-quick-learning-ruby-guide-with-many-practical-examples-this-ruby-programming-book--to-build-real-life-software-projects/18539364/#edition=19727339&idiq=25678249)
Build Your Own Ruby on Rails Web Applications (https://www.thriftbooks.com/w/build-your-own-ruby-on-rails-web-applications_patrick-lenz/725256/item/2315989/?utm_source=google&utm_medium=cpc&utm_campaign=low_vol_backlist_standard_shopping_customer_acquisition&utm_adgroup=&utm_term=&utm_content=593118743925&gad_source=1&gclid=CjwKCAiA1MCrBhAoEiwAC2d64aQyFawuU3znN0VFgGyjR0I-0vrXlseIvht0QPOqx4DjKjdpgjCMZhoC6PcQAvD_BwE#idiq=2315989&edition=3380836)
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/phoenixliveview/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/ -
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(computerscience)
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. -
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 (https://pragprog.com/titles/smgaelixir/genetic-algorithms-in-elixir/) by Sean Moriarity
Machine Learning in Elixir (https://pragprog.com/titles/smelixir/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://www.mathworks.com/products/matlab/programming-with-matlab.html)
https://elixirforum.com/
https://pypi.org/project/pyspark/
Machine Learning Course (https://online.stanford.edu/courses/cs229-machine-learning) from Stanford School of Engineering
Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/) by Aurélien Géron
Data Science for Business (https://data-science-for-biz.com/) by Foster Provost & Tom Fawcett
https://medium.com/@carscomtech
https://github.com/k-burns
Code Beam America (https://codebeamamerica.com/) March, 2024
Special Guests: Alexis Carpenter and Katelynn Burns. - Laat meer zien
