Elixir Wizards

Elixir Wizards

By SmartLogic LLCTechnologyEducationHow To
Download on the App Store

Elixir Wizards episodes

  • "From Inspiration to Execution" with Camber Griffin

    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.

      46 min
    • "DevOps: From Code to Cloud" with Dan Ivovich

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

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

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

        Ansible open source IT automation engine https://www.ansible.com/

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

        44 min
      • "Printing is Ugly" with Joel Meador and Charles Suggs

        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.

          48 min
        • "Keeping it Fresh" with Bilal Hankins and Anna Dorigo

          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.

            36 min
          • "Saga of a Gnarly Report" with Owen and Dan

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

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

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

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

              Prometheus monitoring system & time series database https://prometheus.io/

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

              51 min
            • "Whose Tailwind is it Anyway?" with Ava Slivkoff

              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.

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

                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.

                  45 min
                • "Discovery Discoveries" with Alicia Brindisi and Bri LaVorgna

                  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/Product_requirements_document

                    Special Guests: Alicia Brindisi and Bri LaVorgna.

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

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

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

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

                      https://smartlogic.io/

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

                      Special Guests: Charles Suggs and Joel Meador.

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

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

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

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

                        Software Unscripted Podcast https://feeds.resonaterecordings.com/software-unscripted

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

                        Special Guests: José Valim and Richard Feldman.

                        1 hr 10 min

                      About Elixir Wizards

                      From the publisher's feed

                      Elixir Wizards is an interview-style podcast from SmartLogic featuring conversations with developers, engineers, and industry leaders about the Elixir programming language and the broader software…