get-smart 0.0.1

data/files/rails/websockets/advanced/redis_pubsub_scaling.md

@@ -0,0 +1,18 @@
+## 🗄️ Scaling ActionCable with Redis Pub/Sub
+
+Configure Redis as the adapter to scale WebSocket servers horizontally and leverage Redis Pub/Sub for high-throughput message distribution. Ensure each environment isolates its channels with a prefix.
+
+```yaml
+# config/cable.yml
+production:
+  adapter: redis
+  url: <%= ENV.fetch("REDIS_URL") %>
+  channel_prefix: my_app_production
+```  
+```ruby
+# config/initializers/action_cable.rb
+Rails.application.config.after_initialize do
+  ActionCable.server.config.pubsub_adapter = :redis
+end
+```  
+Adjust Redis pool size and timeouts in `config/redis.yml` or your environment variables to match your expected connection load.

data/files/rails/websockets/beginner/broadcast_from_controller.md

@@ -0,0 +1,23 @@
+## 🔄 Broadcasting Messages from a Controller
+
+You can push data manually from your controllers after creating resources. This is useful for simple chat or notification features without additional setup.
+
+```ruby
+# app/controllers/messages_controller.rb
+class MessagesController < ApplicationController
+  def create
+    @message = Message.create!(message_params)
+    ActionCable.server.broadcast("chat_channel", {
+      content: @message.content,
+      user: @message.user.name
+    })
+    head :ok
+  end
+
+  private
+
+  def message_params
+    params.require(:message).permit(:content, :user_id)
+  end
+end
+```

data/files/rails/websockets/beginner/generate_chat_channel.md

@@ -0,0 +1,19 @@
+## 🚀 Generating a Chat Channel
+
+Action Cable channels are the foundation for real-time features in Rails. You can generate a channel quickly using the Rails generator and define streaming behavior in the channel class.
+
+```bash
+rails generate channel Chat
+```
+
+```ruby
+# app/channels/chat_channel.rb
+class ChatChannel < ApplicationCable::Channel
+  def subscribed
+    stream_from "chat_channel"
+  end
+
+  def unsubscribed
+  end
+end
+```

data/files/rails/websockets/beginner/model_broadcasting.md

@@ -0,0 +1,10 @@
+## 🏭 Broadcasting with Active Record Callbacks
+
+Leverage built-in broadcasting methods in Rails 6+ to automatically stream new records. Use `after_create_commit` in your model for clean and declarative broadcasting.
+
+```ruby
+# app/models/message.rb
+class Message < ApplicationRecord
+  after_create_commit { broadcast_append_to "chat_channel" }
+end
+```

data/files/rails/websockets/beginner/mount_actioncable_in_routes.md

@@ -0,0 +1,11 @@
+## 📡 Mounting Action Cable in Routes
+
+Mount the Action Cable server in your routes to open a WebSocket endpoint. This ensures clients can establish a connection at a given path.
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  mount ActionCable.server => "/cable"
+  # other routes...
+end
+```

data/files/rails/websockets/beginner/subscribe_in_javascript.md

@@ -0,0 +1,19 @@
+## 💻 Subscribing to a Channel in JavaScript
+
+To receive streamed data on the client, subscribe to the channel using the generated consumer. Handle incoming data in the `received` callback to update your UI in real time.
+
+```javascript
+// app/javascript/channels/chat_channel.js
+import consumer from "./consumer"
+
+consumer.subscriptions.create("ChatChannel", {
+  connected() {
+    console.log("Connected to ChatChannel");
+  },
+
+  received(data) {
+    const messages = document.getElementById("messages");
+    messages.insertAdjacentHTML("beforeend", `<p><strong>${data.user}:</strong> ${data.content}</p>`);
+  }
+});
+```

data/files/rails/websockets/expert/backpressure_throttling.md

@@ -0,0 +1,35 @@
+## 🔄 Implementing Backpressure Control in Channels
+Prevent message flooding and protect clients by implementing rate-limiting within your channel. Use a sliding window counter stored in Redis to throttle excessive broadcasts per connection.
+
+```ruby
+# app/channels/application_cable/connection.rb
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    identified_by :current_user, :throttle_key
+
+    def connect
+      self.current_user = find_verified_user
+      self.throttle_key = "ws:#{current_user.id}:throttle"
+    end
+  end
+end
+```
+
+```ruby
+# app/channels/chat_channel.rb
+class ChatChannel < ApplicationCable::Channel
+  MAX_RATE = 5  # messages per 10 seconds
+
+  def speak(data)
+    count = Redis.current.incr(throttle_key)
+    Redis.current.expire(throttle_key, 10) if count == 1
+    if count <= MAX_RATE
+      ActionCable.server.broadcast('chat', data)
+    else
+      transmit(error: 'Rate limit exceeded')
+    end
+  end
+end
+```
+
+This backpressure mechanism drops or rejects messages beyond your threshold, ensuring stability under high load.

data/files/rails/websockets/expert/binary_streaming.md

@@ -0,0 +1,33 @@
+## 📊 High-Performance Binary Data Streaming
+Stream large or binary content (e.g., audio, video frames) over WebSockets by using ActionCable’s `transmit` with raw binary payloads. This approach minimizes JSON overhead and achieves near real-time throughput.
+
+```ruby
+# app/channels/stream_channel.rb
+class StreamChannel < ApplicationCable::Channel
+  def subscribed
+    stream_from "stream_#{params[:session_id]}"
+  end
+
+  def send_chunk(data)
+    binary = Base64.decode64(data['chunk'])
+    ActionCable.server.broadcast("stream_#{params[:session_id]}", binary)
+  end
+end
+```
+
+```javascript
+// app/javascript/channels/stream_channel.js
+import consumer from "../channels/consumer"
+
+const channel = consumer.subscriptions.create(
+  { channel: "StreamChannel", session_id: "abc123" },
+  {
+    received(binary) {
+      // handle ArrayBuffer binary data
+      playAudio(new Uint8Array(binary))
+    }
+  }
+)
+```
+
+This method uses Base64 for transport safety then decodes on the server, streaming raw bytes for low-latency consumption.

data/files/rails/websockets/expert/jwt_connection_authentication.md

@@ -0,0 +1,21 @@
+## 🔒 Advanced Connection Authentication with JWT
+This tip demonstrates how to securely identify and authenticate WebSocket connections in ActionCable using JSON Web Tokens. By verifying the token in the `connect` method, you can enforce per-connection authorization and attach user context to every channel subscription.
+
+```ruby
+# app/channels/application_cable/connection.rb
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    identified_by :current_user
+
+    def connect
+      token = request.params[:token]
+      payload = JWT.decode(token, Rails.application.secrets.jwt_secret, true, algorithm: 'HS256').first
+      self.current_user = User.find(payload['sub'])
+    rescue JWT::DecodeError, ActiveRecord::RecordNotFound
+      reject_unauthorized_connection
+    end
+  end
+end
+```
+
+Above, we decode and validate the JWT, then set `current_user` for downstream channels. Unauthorized or invalid tokens immediately terminate the connection.

data/files/rails/websockets/expert/prometheus_monitoring.md

@@ -0,0 +1,24 @@
+## 🛠️ Instrumenting WebSocket Metrics with Prometheus
+Integrate Prometheus to monitor ActionCable connections, message rates, and latencies. Expose metrics via a Rack endpoint and use custom subscribers to record channel events.
+
+```ruby
+# config/initializers/prometheus_cable.rb
+require 'prometheus/client'
+
+PROM = Prometheus::Client.registry
+connections_gauge = PROM.gauge(:action_cable_connections, 'Active ActionCable connections')
+messages_counter = PROM.counter(:action_cable_messages, 'Total messages processed', labels: [:channel])
+
+ActiveSupport::Notifications.subscribe('action_cable.subscribe') { |_| connections_gauge.increment }
+ActiveSupport::Notifications.subscribe('action_cable.unsubscribe') { |_| connections_gauge.decrement }
+ActiveSupport::Notifications.subscribe('action_cable.broadcast') do |_, _, _, _, payload|
+  messages_counter.increment(labels: { channel: payload[:channel] })
+end
+```
+
+```ruby
+# config/routes.rb
+mount Prometheus::Client::Rack::Exporter, at: '/metrics'
+```
+
+Now Prometheus can scrape `/metrics` to track real-time WebSocket usage and diagnose performance bottlenecks.

data/files/rails/websockets/expert/redis_sentinel_scaling.md

@@ -0,0 +1,29 @@
+## 🚀 Scaling ActionCable with Redis Sentinel and Pub/Sub
+Leverage Redis Sentinel for high availability and automatic failover when scaling WebSocket servers. Configure multiple Sentinel instances in `config/cable.yml` and handle dynamic master discovery for robust Pub/Sub.
+
+```yaml
+# config/cable.yml
+development:
+  adapter: redis
+  url: redis://master-redis.example.com:6379/1
+  channel_prefix: myapp_development
+  sentinel:
+    hosts:
+      - host: sentinel1.example.com
+        port: 26379
+      - host: sentinel2.example.com
+        port: 26379
+    role: master
+```
+
+```ruby
+# config/initializers/redis.rb
+ActionCable.server.config.redis = {
+  url: nil,
+  sentinels: Rails.application.config_for(:cable)['development']['sentinel']['hosts'],
+  role: :master,
+  password: ENV['REDIS_PASSWORD']
+}
+```
+
+This setup ensures ActionCable auto-detects the current master Redis node and reconnects seamlessly if a failover occurs.

data/files/rails/websockets/middle/broadcast_to_user.md

@@ -0,0 +1,23 @@
+## 🎯 Targeted Broadcasting to a Specific User
+
+To send personalized updates, use `stream_for` in your channel and `broadcast_to` in your server-side code. This method isolates messages to a single user rather than broadcasting globally.
+
+```ruby
+# app/channels/notification_channel.rb
+class NotificationChannel < ApplicationCable::Channel
+  def subscribed
+    stream_for current_user
+  end
+end
+
+# app/controllers/notifications_controller.rb
+class NotificationsController < ApplicationController
+  def create
+    @notification = Notification.create!(user: current_user, message: params[:message])
+    NotificationChannel.broadcast_to(current_user, {
+      message: @notification.message
+    })
+    head :ok
+  end
+end
+```

data/files/rails/websockets/middle/connection_authorization.md

@@ -0,0 +1,26 @@
+## 🛡️ Securing Connections with Authorization
+
+Ensure only authenticated users can open WebSocket connections by identifying them in `Connection` and rejecting unauthorized attempts. This guards your channels from unwanted access.
+
+```ruby
+# app/channels/application_cable/connection.rb
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    identified_by :current_user
+
+    def connect
+      self.current_user = find_verified_user
+    end
+
+    private
+
+    def find_verified_user
+      if (user = User.find_by(id: cookies.signed[:user_id]))
+        user
+      else
+        reject_unauthorized_connection
+      end
+    end
+  end
+end
+```

data/files/rails/websockets/middle/redis_adapter_optimization.md

@@ -0,0 +1,14 @@
+## ⚡ Optimizing Action Cable Performance with Redis
+
+For production workloads, use the Redis adapter to scale horizontally and handle high throughput. Configure namespaces and multiple Redis instances to segment pub/sub traffic.
+
+```yaml
+# config/cable.yml
+production:
+  adapter: redis
+  url: redis://localhost:6379/1
+  channel_prefix: myapp_production
+
+# You can use a separate instance for pub/sub:
+# url: redis://redis-pubsub.example.com:6379/2
+```

data/files/rails/websockets/middle/setup_channels_streams.md

@@ -0,0 +1,26 @@
+## 🚀 Organizing Channels and Streams
+
+When working with WebSockets in Rails, you can structure your channels to mirror your resources, keeping real-time logic clean. Define subscription behavior in `subscribed` and manage your streams via `stream_from` or `stream_for` to ensure clients only receive relevant updates.
+
+```ruby
+# app/channels/chat_channel.rb
+class ChatChannel < ApplicationCable::Channel
+  def subscribed
+    # Stream for a specific chat room
+    stream_from "chat_room_#{params[:room]}"
+  end
+
+  def unsubscribed
+    # Cleanup logic if needed
+  end
+end
+
+# app/javascript/channels/chat_channel.js
+import consumer from "channels/consumer"
+
+consumer.subscriptions.create({ channel: "ChatChannel", room: "general" }, {
+  received(data) {
+    console.log("New message:", data)
+  }
+})
+```

data/files/rails/websockets/middle/turbo_streams_integration.md

@@ -0,0 +1,18 @@
+## 🔧 Using Turbo Streams with Action Cable
+
+Leverage Turbo Streams for declarative real-time updates without manual JavaScript wiring. Rails can automatically broadcast updates from models by using built‑in helpers.
+
+```ruby
+# app/models/comment.rb
+class Comment < ApplicationRecord
+  belongs_to :post
+  after_create_commit -> {
+    broadcast_append_to post, target: "comments_list"
+  }
+end
+
+# app/views/posts/show.html.erb
+<div id="comments_list">
+  <%= render @post.comments %>
+</div>
+```

data/files/ruby/arrays/advanced/balanced_chunk_split.md

@@ -0,0 +1,16 @@
+## 🔪 Splitting an Array into N Balanced Chunks
+
+To divide an array into *n* parts as evenly as possible, calculate slice sizes and use `each_with_index` to assign elements. This ensures chunks differ by at most one element, useful for parallel processing or pagination.
+
+```ruby
+def split_into_chunks(arr, n)
+  size, rem = arr.size.divmod(n)
+  arr.each_with_index.with_object(Array.new(n) { [] }) do |(el,i), chunks|
+    idx = i.div(size + (i < rem ? 1 : 0))
+    chunks[idx] << el
+  end
+end
+
+p split_into_chunks((1..10).to_a, 3)
+# => [[1,2,3,4], [5,6,7], [8,9,10]]
+```

data/files/ruby/arrays/advanced/combinatorics_with_arrays.md

@@ -0,0 +1,13 @@
+## 🔀 Generating Combinations and Permutations
+
+Ruby’s Array supports `combination` and `permutation` for combinatorial tasks. Use these with a block to process results on the fly without collecting huge intermediate arrays. Useful for algorithmic puzzles, testing scenarios, or statistical sampling.
+
+```ruby
+letters = %w[a b c d]
+# All 2-letter combinations:
+letters.combination(2) { |combo| p combo }
+# => ["a", "b"], ["a", "c"], ...
+
+# All 3-permutations as arrays:
+p letters.permutation(3).to_a
+```

data/files/ruby/arrays/advanced/custom_uniq.md

@@ -0,0 +1,13 @@
+## 🎯 Deduplicating with Custom Criteria using `uniq`
+
+`Array#uniq` can accept a block to determine uniqueness based on computed keys. This is powerful for de-duplicating complex objects or arrays by specific attributes. The method preserves the first occurrence of each key.
+
+```ruby
+users = [
+  {id: 1, name: 'Alice'},
+  {id: 2, name: 'Bob'},
+  {id: 1, name: 'Alice Smith'}
+]
+unique = users.uniq { |u| u[:id] }
+# => [{id:1, name:'Alice'}, {id:2, name:'Bob'}]
+```

data/files/ruby/arrays/advanced/grouping_with_each_with_object.md

@@ -0,0 +1,12 @@
+## 🏷️ Dual Grouping with `each_with_object`
+
+When you need multiple groupings in one pass, use `each_with_object` to build a hash of arrays or counters. This avoids multiple iterations and keeps the logic in a single traversal for better performance on large datasets.
+
+```ruby
+items = %w[apple banana apricot berry avocado]
+groups = items.each_with_object({ starts_with_a: [], starts_with_b: [] }) do |item, h|
+  key = item.start_with?('a') ? :starts_with_a : :starts_with_b
+  h[key] << item
+end
+# => {starts_with_a: ["apple","apricot","avocado"], starts_with_b: ["banana","berry"]}
+```

data/files/ruby/arrays/advanced/lazy_enumerators.md

@@ -0,0 +1,10 @@
+## 🐢 Processing Large Arrays Lazily with `Enumerator::Lazy`
+
+When working with huge or infinite sequences, convert your array (or Range) to a lazy enumerator to defer computation until needed. Chaining `lazy.select.map` prevents building intermediate arrays and minimizes memory overhead. Call methods like `first` or `take` to realize only the required elements.
+
+```ruby
+numbers = (1..Float::INFINITY).lazy
+even_squares = numbers.select(&:even?).map { |n| n**2 }
+p even_squares.first(5)
+# => [4, 16, 36, 64, 100]
+```

data/files/ruby/arrays/advanced/pattern_matching_arrays.md

@@ -0,0 +1,15 @@
+## 🧩 Destructuring Nested Arrays with Pattern Matching
+
+Ruby 3’s pattern matching can unpack complex nested arrays in a concise way. Use the `in` keyword in `case` or within method parameters to extract values, ignoring or capturing rest elements. This makes your code more declarative and reduces manual indexing.
+
+```ruby
+def analyze(data)
+  case data
+  in [user_id, [year, month, day], *tags]
+    puts "User #{user_id} on #{year}-#{month}-#{day} with tags: #{tags.inspect}"
+  end
+end
+
+data = [42, [2023, 8, 15], 'ruby', 'arrays']
+analyze(data)
+```

data/files/ruby/arrays/advanced/pipeline_with_tap_then.md

@@ -0,0 +1,12 @@
+## 🔗 Fluent Array Pipelines with `then` and `tap`
+
+Use `tap` to insert side‑effects (e.g., logging or debugging) without breaking the method chain, and `then` to transform the entire result at a given step. This keeps your pipeline readable and avoids temporary variables.
+
+```ruby
+result = [1,2,3,4]
+  .select(&:even?)
+  .tap { |evens| STDOUT.puts("Evens: #{evens.inspect}") }
+  .map { |n| n * n }
+  .then { |squares| squares.sum }
+# Logs "Evens: [2,4]" then returns 20
+```

data/files/ruby/arrays/advanced/selective_flatten.md

@@ -0,0 +1,14 @@
+## 📦 Selective Depth Flattening with `flat_map` and `flatten`
+
+Use `flat_map` to map and flatten one level in a single pass, then call `flatten(depth)` for deeper levels. This two-step approach avoids unnecessary deep flattening and keeps your intentions clear. Ideal for nested list processing where only certain levels need merging.
+
+```ruby
+data = [[1, [2, 3]], [4, [5, [6]]]]
+# Flatten one level after mapping:
+step1 = data.flat_map { |a, b| [a, b] }
+# => [1, [2,3], 4, [5,[6]]]
+
+# Then flatten just one more level:
+result = step1.flatten(1)
+# => [1, 2, 3, 4, 5, [6]]
+```

data/files/ruby/arrays/advanced/slice_when_chunking.md

@@ -0,0 +1,9 @@
+## 🪓 Efficient Custom Chunking with `slice_when`
+
+Use `slice_when` to divide an array into chunks based on a custom predicate. It yields an Enumerator of subarrays, splitting whenever the block returns true for a pair of consecutive elements. This is ideal for grouping ranges or segments without precomputing indices.
+
+```ruby
+arr = [1, 2, 3, 5, 6, 10]
+chunks = arr.slice_when { |prev, curr| curr != prev + 1 }.to_a
+# => [[1, 2, 3], [5, 6], [10]]
+```

data/files/ruby/arrays/advanced/transpose_jagged_arrays.md

@@ -0,0 +1,11 @@
+## 🔄 Transposing Irregular Matrices
+
+`Array#transpose` expects uniform subarrays, but you can zip with a fill value to handle jagged arrays. First determine the maximum width, then pad each row before transposing. This technique reshapes uneven data grids safely.
+
+```ruby
+matrix = [[1,2,3], [4,5], [6]]
+max_cols = matrix.map(&:size).max
+padded = matrix.map { |row| row + [nil] * (max_cols - row.size) }
+transposed = padded.transpose
+# => [[1,4,6], [2,5,nil], [3,nil,nil]]
+```

data/files/ruby/arrays/beginner/accessing_elements.md

@@ -0,0 +1,17 @@
+## 🔍 Accessing Elements
+You can retrieve elements by their index, where Ruby arrays are zero-indexed. Negative indices start counting from the end, and methods like `first`, `last`, or `fetch` give more control or safer access with defaults.
+
+```ruby
+colors = ['red', 'green', 'blue']
+
+# By index
+colors[0]        # => 'red'
+colors[-1]       # => 'blue'
+
+# Using helper methods
+colors.first     # => 'red'
+colors.last      # => 'blue'
+
+# Safe fetch with default
+colors.fetch(5, 'unknown')  # => 'unknown'
+```

data/files/ruby/arrays/beginner/adding_elements.md

@@ -0,0 +1,13 @@
+## ➕ Adding Elements
+To grow an array, use `push` or the shovel operator (`<<`) to append, and `unshift` to prepend. These methods modify the array in place and return the array itself, making chaining possible.
+
+```ruby
+numbers = [2, 3]
+
+# Append to end
+numbers.push(4)    # => [2, 3, 4]
+numbers << 5        # => [2, 3, 4, 5]
+
+# Prepend to start
+numbers.unshift(1)  # => [1, 2, 3, 4, 5]
+```

data/files/ruby/arrays/beginner/array_creation.md

@@ -0,0 +1,13 @@
+## 🎉 Creating Arrays
+Ruby arrays can be created using the literal syntax `[]` or the `Array.new` constructor. Literals are concise for most use cases, while `Array.new` allows you to set an initial size and a default value for each element.
+
+```ruby
+# Using a literal
+fruits = ['apple', 'banana', 'cherry']
+
+# Using Array.new for fixed size
+empty_slots = Array.new(5)            # => [nil, nil, nil, nil, nil]
+
+# With a default value
+zeros = Array.new(3, 0)               # => [0, 0, 0]
+```

data/files/ruby/arrays/beginner/cleaning_arrays.md

@@ -0,0 +1,8 @@
+## 🧹 Cleaning up Arrays with uniq and compact
+To remove duplicates use `uniq`, and to drop `nil` values use `compact`. Chain them to clean data in one go.
+
+```ruby
+data = [1, nil, 2, 2, nil, 3]
+
+clean = data.uniq.compact  # => [1, 2, 3]
+```

data/files/ruby/arrays/beginner/combining_arrays.md

@@ -0,0 +1,13 @@
+## 🤝 Combining Arrays
+You can merge arrays with the `+` operator or the `concat` method. The `+` operator returns a new array, while `concat` modifies the original one.
+
+```ruby
+a = [1, 2]
+b = [3, 4]
+
+# Non-destructive
+c = a + b   # => [1,2,3,4], a unchanged
+
+# Destructive
+a.concat(b) # => [1,2,3,4], a is now modified
+```

data/files/ruby/arrays/beginner/destructuring_assignment.md

@@ -0,0 +1,11 @@
+## 🪶 Destructuring with Parallel Assignment
+Ruby lets you assign multiple variables in one go from an array. Use the splat operator (`*`) to capture remaining elements into another array.
+
+```ruby
+info = ['Jane', 'Doe', 30, 'Engineer']
+
+first_name, last_name, *details = info
+# first_name => 'Jane'
+# last_name  => 'Doe'
+# details    => [30, 'Engineer']
+```

data/files/ruby/arrays/beginner/iterating_each.md

@@ -0,0 +1,14 @@
+## 🔁 Iterating with each
+The `each` method is your go-to for looping through array elements. It yields each item to a block, where you can perform actions like logging or accumulating results.
+
+```ruby
+names = ['Alice', 'Bob', 'Carol']
+
+names.each do |name|
+  puts "Hello, #{name}!"
+end
+# Output:
+# Hello, Alice!
+# Hello, Bob!
+# Hello, Carol!
+```

data/files/ruby/arrays/beginner/map_transform.md

@@ -0,0 +1,10 @@
+## 🗺️ Transforming with map
+Use `map` to apply a transformation to each element, returning a new array of results. This is ideal for tasks like formatting or mathematical operations.
+
+```ruby
+prices = [100, 200, 300]
+
+# Add 10% tax to each price
+taxed_prices = prices.map { |p| (p * 1.1).round }
+# => [110, 220, 330]
+```

data/files/ruby/arrays/beginner/removing_elements.md

@@ -0,0 +1,15 @@
+## ➖ Removing Elements
+To remove items from an array, use `pop` (last), `shift` (first), or methods like `delete_at` for a specific index. Each method alters the array and returns the removed element, letting you reuse it if needed.
+
+```ruby
+letters = ['a', 'b', 'c', 'd']
+
+# Remove last element
+letters.pop        # => 'd', letters now ['a','b','c']
+
+# Remove first element
+letters.shift      # => 'a', letters now ['b','c']
+
+# Remove at index
+letters.delete_at(1) # => 'c', letters now ['b']
+```

data/files/ruby/arrays/beginner/select_filter.md

@@ -0,0 +1,9 @@
+## 🎯 Filtering with select
+`select` keeps elements matching a condition, while `reject` drops them. Both return a new array so your original data stays intact.
+
+```ruby
+numbers = [1, 2, 3, 4, 5]
+
+even = numbers.select { |n| n.even? }   # => [2, 4]
+odd  = numbers.reject { |n| n.even? }   # => [1, 3, 5]
+```