Elixir Wizards SmartLogic LLC
-
- Technology
Elixir Wizards is an interview-style podcast for anyone interested in functional programming and the Elixir Programming Language. Hosted by SmartLogic engineers and Elixirists Owen Bickford, Dan Ivovich, and Sundi Myint, this show features in-depth discussions with some of the brightest minds in the industry, discussing training and documentation in Phoenix LiveView, the evolution of programming languages, Erlang VM, and more.
In the current season, we're branching out from Elixir to compare notes with thought leaders and software engineers from programming languages like JavaScript, Ruby on Rails, Go, Scala, Java, and more. Each episode will take a deep dive into a topic from Machine Learning and AI, to ECS and game development, to education and community.
Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)
-
"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. -
"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/ -
"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. -
"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. -
"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/ -
"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.