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?

    Klik hier om de feed te vernieuwen.

  • 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.