Listing Links for tag Elixir

Elixir x

Tags

see all

Writing dynamic Ecto queries with Composite (dev.to)

Ecto Queries Coding Elixir

This article introduces the Composite library for simplifying the writing of dynamic Ecto queries. It covers the basic principles of dynamic queries, demonstrates an alternative approach using Composite, and explains how Composite can improve query efficiency through features like dependencies. Links to the Ecto docs and Composite’s source code are provided for further reading.
Main Points
- Need for an alternative approach to dynamic queriesAnother article is needed despite the existing one in Ecto docs because it suggests a different organization of the final code for dynamic queries.
- Principles of dynamic Ecto query writingWriting dynamic Ecto queries is about the optional application of functions, aiming for query composition based on given input parameters.
- Introduction to the Composite libraryThe Composite library is a result of refactoring various approaches to writing dynamic Ecto queries, showcasing an alternative implementation that is simpler and more efficient.
12

200

47

63
How to Configure Ecto to Show Queries in Tests (elixirmerge.com)

Elixir Ecto Debugging Query Optimization

A simple configuration change in the config/test.exs file, setting the logger’s level to debug, enables developers to see the exact queries executed during Elixir application tests, aiding in debugging and optimization efforts.
Main Points
- Changing logger's level to debug in test configuration helps understand database interactions.By adjusting the logger's level to debug in the `config/test.exs` file, developers can gain insight into the exact queries being executed during test runs. This change is made by updating the line `config :logger, level: :warning` to `config :logger, level: :debug`.
12

200

47

63
Using Decision Tables in Elixir Applications (q-the-hacker.com)

Elixir Tablex Decision Table

The article discusses the use of Decision Tables in Elixir applications, emphasizing their value in managing complex business rules through the Tablex library. It explains how decision tables serve as a structured method for determining actions based on inputs and how they can be optimized for performance by compiling them into Elixir code. The article also touches on the potential benefits of using decision tables, including streamlined configuration management and consistent performance levels, while hinting at exploring advanced features in future articles.
Main Points
- Understanding the value of Decision TablesA Decision Table provides a structured format for determining actions based on various inputs, making it an invaluable tool for managing complex business rules.
- Implementing Decision Tables with TablexThe Tablex library simplifies the creation and management of decision tables in Elixir, allowing even non-programmers to update rules easily.
- Optimizing Decision Table PerformancePerformance can be significantly improved by compiling decision tables into Elixir code, thus avoiding the overhead of parsing decision tables for each execution.
12

200

47

63
Ash 3.0 Teasers! (elixirforum.com)

Elixir Developer Experience Security Domain Modeling Ash 3.0

Ash 3.0 Teasers unveil a range of improvements, emphasizing domain modeling, security, and developer experience. Key features include centralized action definitions, domain-specific policies, increased action safety through explicitness, and comprehensive documentation enhancements.
Main Points
- Centralized action definitions through code interfacesAsh 3.0 introduces code interfaces on domain modules, centralizing action definitions and emphasizing domains in application structuring.
- Simplified security with domain-specific policiesDomain-specific policies in Ash 3.0 enable broad application of authorization logic, simplifying security management.
- Enhanced action safety and explicitnessThe new version prioritizes safety and explicitness in actions, making it necessary to explicitly declare attributes that an action accepts.
- Improved developer experience and documentationDeveloper experience improvements include enhanced autocomplete support and comprehensive documentation, particularly around code interfaces.
12

200

47

63
GitHub - RaymondLoranger/io_ansi_table: Writes data to "stdio" in a table with borders and colors. Can choose a table style to change the look of the table. (github.com)

Elixir library table formatting programming Data Visualization

The IO ANSI Table library for Elixir enables the formatting of data into tables with borders and colors, offering a variety of styles and customization options. It is inspired by the book ‘Programming Elixir’ by Dave Thomas and provides numerous features in its latest version, including multi-column sorting, alternating row attributes, and extended color support among others. The library supports practical application examples and is utilized by other packages.
Main Points
- Functionality and PurposeIO ANSI Table is a utility library for Elixir that allows data to be formatted and presented in a table format, with various styling and color options.
- InspirationThe library is notably inspired by the book 'Programming Elixir' by Dave Thomas, showcasing its educational influence.
- Examples & UsabilityIt includes examples and use cases, demonstrating practical applications and customization options.
- Latest Version EnhancementsThe latest version of IO ANSI Table introduces several new features and improvements, emphasizing ongoing development and enhancements.
12

200

47

63
Scaling a streaming service to hundreds of thousands of concurrent viewers at Veeps (elixir-lang.org)

Elixir Veeps streaming service scaling system efficiency LiveView

The article describes how the streaming service Veeps used Elixir to scale its performance, handling hundreds of thousands of concurrent viewers. The transition from Ruby on Rails to Elixir greatly improved system efficiency and concurrency handling. Elixir’s ecosystem provided robust solutions for technical challenges, with LiveView simplifying front-end and back-end collaboration. The case illustrates the benefits of using Elixir for high-scale challenges, achieving significant operational simplicity and increased developer productivity.
Main Points
- Successful adoption of Elixir at VeepsVeeps successfully utilized Elixir to enhance its streaming service's scalability and performance, handling hundreds of thousands of concurrent viewers.
- Efficiency improvement with ElixirThe transition from Ruby on Rails to Elixir marked a significant improvement in system efficiency and capacity for concurrent user handling.
- Elixir's ecosystem benefitsElixir's ecosystem provided Veeps with essential tools for architectural simplification and operational efficiency, minimizing the need for external dependencies.
- Collaboration enhancement with LiveViewThe use of LiveView significantly simplified front-end and back-end developer collaboration, leading to enhanced productivity.
12

200

47

63
Designing Concurrent Systems on the BEAM (happihacking.com)

development Erlang Elixir architecture design processes BEAM Concurrency Actor model system design maintainability Technology

Designing concurrent systems on the BEAM involves leveraging its concurrency model, rooted in the actor model, for process isolation and communication. A fundamental understanding that processes are not equated with code, and visualization strategies like considering processes as workers, are pivotal for system design. Key strategies include clear task allocation, flow-based structuring, and understanding process archetypes. Structuring code according to business domains further aligns technical solutions with business strategy, promoting maintainable and scalable system architecture.
Main Points
- Overview of BEAM's Concurrency ModelThe BEAM's concurrency model, rooted in the actor model, focuses on lightweight, isolated processes communicating through message passing, fostering system resilience and maintainability.
- Clearing Misconceptions: Processes ≠ CodeMisinterpretation of processes as code can obscure the understanding of BEAM's concurrency model, but recognizing their separation illuminates design considerations for concurrency.
- Visualizing Processes for Better UnderstandingPersonifying processes as gnomes offers a tangible understanding of their independent operation, state management, and communication, enriching the conceptual grasp of concurrent system design on BEAM.
- Key Design Strategies for Concurrent SystemsTask allocation based on responsibility, structuring systems around data flow, and categorizing processes according to specific archetypes are critical strategies for designing concurrent systems on BEAM.
12

200

47

63