Introduction

In the ever-evolving landscape of programming, Ruby stands out with its elegant syntax and powerful libraries, making it an intriguing choice for machine learning and artificial neural networks. While Python might dominate the deep learning scene with libraries like TensorFlow and PyTorch, Ruby’s ecosystem has been quietly growing, offering unique opportunities for developers who prefer or are already invested in Ruby. Here’s how you can start crafting your first neural network with Ruby.

Why Ruby for Neural Networks?

Ruby might not be the first language you think of when diving into neural networks, but its ease of use, combined with gems like numo-narray for numerical computations and ruby-fann for neural network creation, makes it a viable option. Ruby’s expressive nature allows for concise yet readable code, which is beneficial when experimenting with complex structures like neural networks.

Step-by-Step Guide to Build Your First Neural Network with Ruby

Setup Your Environment:

• Ensure you have Ruby installed. If you’re using a version manager like RVM or rbenv, set up your Ruby version.
• Install necessary gems:

gem install ruby-fann numo-narray

Understanding the Basics:

Before coding, grasp the basic architecture of neural networks: inputs, weights, biases, layers (input, hidden, output), and how they interact through activation functions.

Creating a Simple Neural Network:

Let’s create a basic feedforward neural network for binary classification, inspired by the examples found in Ruby communities.

require 'ruby-fann'

# Create a neural network with 2 inputs, 6 neurons in a single hidden layer, and 1 output neuron
network = RubyFann::Standard.new(num_inputs: 2, hidden_neurons: [6], num_outputs: 1)

# Training data: Here, we're using hypothetical data for alcohol consumption vs. academic performance
x_train = [[0.1, 0.2], [0.3, 0.4], [0.5, 0.6], [0.7, 0.8]]
y_train = [0.0, 0.0, 1.0, 1.0]

# Train the network
train_data = RubyFann::TrainData.new(x_train, y_train)
network.train_on_data(train_data, 1000, 10, 0.1)

# Test the network
puts network.run([0.1, 0.2]) # Should predict close to 0
puts network.run([0.7, 0.8]) # Should predict close to 1

Explanation:

• Inputs: We’re using two inputs which could represent, for example, workday and weekend alcohol consumption.
• Training: The network learns from our provided data through backpropagation, adjusting weights to minimize error.
• Testing: We test the network with unseen data to see how well it generalizes.

Advanced Tips

• Experiment with Architectures: Try different numbers of hidden layers or neurons to see how they affect learning.
• Custom Activation Functions: While ruby-fann provides common activation functions, understanding how to implement or change these can deepen your knowledge.
• Real-World Data: Apply your network to real datasets. Libraries like daru for data manipulation in Ruby can be useful here.

Conclusion

Creating a neural network in Ruby might not be the mainstream choice, but it’s a refreshing approach for Rubyists looking to expand into AI. By leveraging Ruby’s ecosystem, you can build, train, and deploy neural networks that perform tasks like classification or prediction. Remember, the key to mastering neural networks isn’t just in the code but in understanding the underlying concepts of machine learning, which Ruby, with its community-driven development, makes quite accessible.

For those intrigued by this intersection of Ruby and AI, dive deeper into gems, explore more complex architectures, and contribute to the evolving landscape of Ruby in AI. Your journey in crafting neural networks with Ruby could lead to innovative solutions, tailored precisely for the Ruby community’s needs.

Happy Coding!

Conway’s Game of Life, a cellular automaton devised by the British mathematician John Horton Conway, is not just a game but a fascinating simulation of life, death, and evolution based on simple rules. In this blog, we’ll explore how to implement this classic simulation using Ruby, a dynamic, object-oriented programming language known for its simplicity and readability.

What is Conway’s Game of Life?

Before diving into code, let’s briefly understand the game:

• Grid: The game is played on an infinite grid of square cells, each of which is in one of two states, alive or dead.

• Rules:

  • Any live cell with fewer than two live neighbors dies, as if by underpopulation.
  • Any live cell with two or three live neighbors lives on to the next generation.
  • Any live cell with more than three live neighbors dies, as if by overpopulation.
  • Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.

Setting Up Your Ruby Environment

Ensure you have Ruby installed on your system. You can check by running:

ruby -v

If you don’t have Ruby, you can download it from ruby-lang.org or use a version manager like RVM or rbenv.

Step-by-Step Implementation

Create a file called game_of_life.rb using your favorite editor. I use AstroNvim

1. Creating the Grid

First, we’ll create a class to represent our grid:

# game-of-life.rb
class Grid
  attr_accessor :cells

  def initialize(width, height)
    @cells = Array.new(height) { Array.new(width, 0) }
  end

  def [](x, y)
    @cells[y][x]
  end

  def []=(x, y, value)
    @cells[y][x] = value
  end
end

2. Initializing the Grid with Random Cells

We’ll use Ruby’s rand method to randomly initialize cells:

def initialize_random(grid, density = 0.5)
  grid.cells.each_with_index do |row, y|
    row.each_with_index do |_, x|
      grid[x, y] = rand < density ? 1 : 0
    end
  end
end

3. Counting Neighbors

A crucial function to determine the next state of a cell:

def count_neighbors(grid, x, y)
  directions = [
    [-1, -1], [-1, 0], [-1, 1],
    [ 0, -1],          [ 0, 1],
    [ 1, -1], [ 1, 0], [ 1, 1]
  ]

  count = 0
  directions.each do |dx, dy|
    nx, ny = x + dx, y + dy
    count += 1 if grid[nx, ny] == 1 if grid.cells[ny] && grid.cells[ny][nx]
  end
  count
end

4. Next Generation

Here’s where we apply the rules:

def next_generation(grid)
  new_grid = Grid.new(grid.cells[0].size, grid.cells.size)

  grid.cells.each_with_index do |row, y|
    row.each_with_index do |_, x|
      neighbors = count_neighbors(grid, x, y)
      if grid[x, y] == 1
        new_grid[x, y] = 1 if neighbors == 2 || neighbors == 3
      else
        new_grid[x, y] = 1 if neighbors == 3
      end
    end
  end

  new_grid
end

5. Displaying the Grid

For simplicity, let’s use ASCII:

def display(grid)
  system 'clear'
  grid.cells.each do |row|
    puts row.map { |cell| cell == 1 ? '■' : ' ' }.join
  end
end

6. Main Loop

Now, let’s tie it all together:

width, height = 50, 20
grid = Grid.new(width, height)
initialize_random(grid)

loop do
  display(grid)
  grid = next_generation(grid)
  sleep 0.1
end

Running Your Game

Save this code in a file, say game_of_life.rb, and run it with:

ruby game_of_life.rb

You should see the grid updating every 0.1 seconds, showing the evolution of life forms.

Conclusion

Building Conway’s Game of Life in Ruby not only teaches you about cellular automata but also reinforces Ruby’s syntax, object-oriented programming concepts, and how to manage state changes in a simple yet effective manner. This project can be extended by adding user input for initial patterns, implementing wrap-around edges for an infinite grid, or even visualizing it with a GUI library like Shoes or GTK.

Remember, the beauty of programming lies in experimentation. Modify the rules, change the grid’s behavior, or even introduce new elements to see how they affect the simulation. Happy coding!

Chatwoot: The Open-Source Powerhouse Alternative to Live-Chat and Tidio

In the world of customer support, having a reliable, feature-rich platform can make all the difference. While services like Live-Chat and Tidio have their merits, Chatwoot emerges as a formidable open-source alternative, offering flexibility, control, and a community-driven approach to customer engagement. Here’s why Chatwoot stands out and how you can set it up on a Linux VM.

Why Choose Chatwoot?

Open Source Flexibility

Chatwoot’s open-source nature means you’re not just using a service; you’re part of a community. You can customize, extend, and integrate it as you see fit, without being locked into proprietary systems.

Multi-Channel Support

From website live-chat, email, to social media platforms like X (formerly Twitter), and even WhatsApp, Chatwoot consolidates all your customer interactions into one inbox, simplifying management.

Cost-Effective

Being open-source, Chatwoot can significantly reduce costs associated with customer support tools, especially beneficial for startups and small businesses.

Self-Hosted Security

Hosting Chatwoot on your own Linux VM gives you full control over your data, enhancing security and privacy, which is crucial in today’s digital landscape.

Installing Chatwoot on a Linux VM

Here’s a straightforward guide to get Chatwoot running on an Ubuntu-based Linux VM:

Prerequisites:

• A Linux VM (Ubuntu 20.04 LTS or newer recommended)
• Minimum 4GB RAM, 4vCPU for small to medium traffic
• Ensure you have sudo or root access

Step-by-Step Installation:

1. Update Your System:

   sudo apt update && sudo apt upgrade -y
   

2. Install Dependencies:

   sudo apt-get install -y git postgresql postgresql-contrib nodejs npm redis-server imagemagick
   

   • Node.js: Chatwoot requires Node.js. Install the latest LTS version:

     curl -sL https://deb.nodesource.com/setup_20.x | sudo -E bash -
     sudo apt-get install -y nodejs
     

   • Yarn: Instead of npm, you might want to use Yarn:

     sudo npm install --global yarn
     

3. Set Up Ruby:

   sudo apt-get install -y software-properties-common
   sudo add-apt-repository -y ppa:rael-gc/rvm
   sudo apt-get update
   sudo apt-get install -y rvm
   source /etc/profile.d/rvm.sh
   rvm install ruby-3.2.2
   rvm use 3.2.2 --default
   

4. Install Chatwoot:
   • Clone the repository and setup:

     git clone https://github.com/chatwoot/chatwoot.git
     cd chatwoot
     bundle install
     yarn install
     

   • Configure your environment variables in .env file. You’ll need to set up your database, Redis, and email settings.
5. Database Setup:

   sudo -u postgres psql
   # Inside psql, create user and database for Chatwoot
   CREATE USER chatwoot CREATEDB;
   CREATE DATABASE chatwoot_production WITH OWNER chatwoot;
   \q
   

6. Migrate and Seed the Database:

   RAILS_ENV=production bundle exec rake db:create
   RAILS_ENV=production bundle exec rake db:reset
   

7. Precompile Assets:

   RAILS_ENV=production bundle exec rake assets:precompile
   

8. Start Chatwoot: Use cwctl if available, or manually start the services:

   rails s -e production
   

   For background workers:

   RAILS_ENV=production bundle exec sidekiq -C config/sidekiq.yml
   

9. Accessing Chatwoot: Open your web browser and navigate to http://your_vm_ip:3000. Follow the setup to create your admin account.

Conclusion

Chatwoot not only stands as a robust alternative to Live-Chat and Tidio but also brings the power of open-source to customer support. Its installation might seem technical, but with this guide, you’re well-equipped to set up your own instance on a Linux VM. Enjoy the freedom, control, and community support that comes with Chatwoot, enhancing your customer interaction like never before.

Happy coding!

Though this initial saddened me, I believe I’ve found a better NeoVim distribution in AstroNvim.

Here are the editors I tried after Lunarvim died, rated in order of awesomeness:

1. AstroNvim
2. LazyVim
3. NvChad

• LazyVim second place to Astro. It was easy to setup but a bit more painful to customize.
• NvChad third place. It seems very capable. Not difficult to setup but again, painful to customize when compared to AstroNvim.

AstroNvim is fairly lean. Only a few plugins come installed by default and the keystroke mappings are sane and easy to customize using WhichKey or standard vim and nvim mappings. Lazy is great for plugins. Treesitter is there and highly useful. Supports LuaSnip with vscode style snippet files. LSP is pre-configured with sane defaults and easy to install language support for things that are missing. AutoCmds are easy to configure, etc.

It only took me about an hour to move my Lunarvim plugins, configs and settings over to AstroNvim.

Now I’m just hoping that it too will not become abandoned or unmaintained.

🤞🏼

The pattern is a common one where an enterprising programmer decides they want to create their own editor, providing time-saving features. In most cases the new editors start off with the best intentions. They come off the line lean, with enough useful features to gain significant coder adoption. Then, in most cases, they become fat, slow and bloated or fall into un-maintained mode where bugs are no longer fixed and features are not updated.

The problem with most graphical IDE editors:

• They are platform specific and non-portable. (Textmate, etc.)
• They “protect” coders from learning the funatmentals of programming. (compiling, debugging, etc.)
• They track you. They may do this blatantly like “VS Code”, which pings home every single time you launch it, or they may do it backhandedly by automatically checking for updates without your permission.
• They don’t work on remote code. If you have to ssh into a remote server and edit things, you will have to use nano, vim or whatever the server admin allows but you most likely won’t be able to use a graphical editor. To be fair, some editors support SFTP file editing, like Sublime Text, but it can be a pain to setup and work with, and if the server admin does not allow SFTP you are out of luck.

Fortunately, I’ve never had to use ED or TECO, but here is a list of editors that I’ve used extensively over my career along with their eventual problems that made me switch to something else. I started my programming career on a TI-99 computer, then quickly switched to Windows in the early 90’s, but soon switched to Mac and then finally Linux. This list reflects the progression of those platform choices.

BASIC - TI-99

A very featureless, proprietary text editor for the TI-99. Very tedious to use compared to modern editors.

Abandoned this editor and platform to move on to PC/DOS programming.

Visual Basic 2 - Windows

A revolutionary experience in programming with it’s forms editor and IDE approach. It borrowed keystrokes and features from Emacs. Eventually became fat and bloated like most MS products. See Visual Studio

Moved on after getting a C++ programming job.

Visual C++ 1 - Windows

Similar to the VB IDE, but for C/C++

Moved on after switching to a Java programming job. NOTE: These Visual X editors eventually became Visual Studio, which is now incredibly fat, slow and bloated. The problem with these MS editors is that people come out of school and start using them and fail to learn the fundamentals because the IDE hides too much of that from the user. New programmers get used to IDEs like this and then don’t know how to compile their code, setup a project or run a debugger without using them.

Textmate - Mac

Not an IDE but a great text editor for Ruby programmers. Easily customizable using Ruby, supporting complicated snippets.

Moved on after switching from Mac to Linux.

Sublime Text - Linux

Also not an IDE but a lean, comprehensive, fast programmer’s editor, highly customizable using Python.

Moved on because there were some version hiccups where it wasn’t updated for over a year and Sublime Text 3 has become fat and bloated like most other editors.

Atom - Linux

A very promising programmer’s editor, easy to hack and customize for your needs as long as you know Javascript and CSS.

Moved on because it was abandoned in 2022, and I did not like having to drop down to Javascript in order to customize it.

VSCodium - Linux

A fat IDE with hundreds of plugins to support many languages and comprehensive customizations.

Moved on because it is slow and just feels fat and bloated, especially when all I want to do is quickly write a Bash script or other type of small text file.

Vim - Linux

Finally decided to switch to Vim after wanting to for years. The benefits of Vim are:

• It is terminal/curses based which means it can be used over SSH on remote servers
• It is incredibly lean and fast to load, edit and save files
• It is portable to virtually every platform
• It can be easily extended to meet a programmer’s needs
• It doesn’t track you by phoning home every time you launch it
• It is extremely stable

The reason for delaying the switch for so long is mainly the learning curve. As alluded to above, you get used to an IDE and it’s extensive features with easy to use keymaps and mouse features. Non-Vim users, like myself for so many years, become spoiled and fear the learning curve. I didn’t want to re-learn how to do block selections, block editing, the new Vim keystrokes, Command mode vs Insert mode, etc.

It took about 2 weeks to become proficient in Vim after finally switching. I am still learning how to use it more efficiently but the benefits have far outweighed the drawbacks and fear.

Lunarvim - Linux

After finally switching to Lunarvim (an IDE layer for Neovim), I’ve found editor nirvana. Lunarvim makes it easy to customize and maintain Vim as a very usable IDE. Lunarvim features LUA config scripts, snippets and you can use Neovim and Vim plugins

I want to acknowledge the religious fervor surrounding two of the oldest editors, Emacs and Vim. I have no experience with vanilla Emacs but I’ve used editors that were heavily based on it. Emacs was released in 1976, Vim in 1991. They are both still going strong and have a huge userbase.

If you decide to switch from a graphical IDE to Vim, Neovim or Lunarvim, my advice is to be patient but persistent. It is easy to be tempted to switch back to your graphical IDE of choice when you have deadlines to meet and are still learning Vim. Don’t do it! Fight through and learn the Vim keystrokes or find plugins to help you. Once you finally dive in and abandon the graphical alternatives you will find yourself becomming more proficient and faster at writing code than ever before.

Happy coding!

After looking into the Chrome flags I discovered this:

There are several options here. I chose “Enable Without Ring and 30% Opacity” which looks much more intuitive. The favicons now get faded but they don’t have the little circle around them. Choose whichever option works best for you.

Cheers!

Postgres SQL

Here’s the Postgres SQL to aggregate data by month:

select date_trunc('month', delivered_at) as month, count(id) as count
from "user_properties"
where "user_properties"."user_id" = 1
group by date_trunc('month', delivered_at)
order by "month" desc
;

Results look like this:

Substitute your own ids and DateTime column for your needs.

ActiveRecord Scope

Here is the same result as an ActiveRecord scope:

scope :delivered_by_month, lambda { |user_id|
    UserProperty.select("date_trunc('month', delivered_at) as month, count(id) as count")
        .where(user_id: user_id)
        .group("date_trunc('month', delivered_at)")
        .order(month: :desc)
}

You can use this in your HTML template like this (note: we use HAML here):

%table#lead-deliveries.table.display.is-striped.is-fullwidth
  %thead
    %tr
      %th Count
      %th Month
  %tbody
    - @leads.each do |delivery|
      %tr
        %td= delivery.count
        %td= delivery&.month&.strftime('%B, %Y')

…which will look something like this:

Cheers!

An AppImage is a self contained app with all of it’s required libraries and everything it needs to run on Linux the way the author intends. To run an AppImage you just have to download it and/or unpack/unzip it into a directory, make it executable then run it. There is no “installation” process, nothing to create a desktop icon or menu entry.

I use Albert on Linux, which I highly recommend as an app-launcher. To get Albert to see my AppImages or to add an AppImage to the application menus we have to create a .desktop file at $HOME/.local/share/applications. For example, here’s my entry for Lepton…

[Desktop Entry]
Name=Lepton
GenericName=Gist Editor
Comment=Lepton Gist GUI
Exec=sh -c "/home/midwire/AppImages/Lepton-1.10.0.AppImage --in-process-gpu"
Keywords=Gist
Icon=lepton.png
Terminal=false
Type=Application
Categories=Programming;

The first line is a standard string [Desktop Entry]. This is required.

• Name can be anything you like
• GenericName can be anything you like
• Comment is the description of the app
• Exec is the command-line needed to run the app
• Keywords will allow you to find the menu item. Semi-colon separated
• Icon is optional but will provide a custom icon for the app entry. Icons must be located at ~/.icons and only use the base filename, not the full path.
• Terminal can be true or false depending on whether you want to run the app in a terminal
• Type always use Application for AppImages
• Categories is optional but allows the system menu to place the entry where it belongs in your categorized menus

And that’s it. Now your AppImage will appear in Albert and in your system menus.

Simple as:

[This is a link to Ruby on Rails](https://rubyonrails.org/)

It is the little things that make the world go around.

Cheers

–Geeze

render_to_string(
  template: 'notifiers/base_notifier.html.inky-haml',
  layout: 'mailer.html.inky-haml'
)

You will get a nasty little warning: DEPRECATION WARNING: Rendering actions with '.' in the name is deprecated: 😡🤬

So how do we render the correct template and layout without running into this deprecation?

The documentation for render mentions several options we can pass to the method. After reading that, the first likely solution would be to try formats or variants, neither of which will remove the deprecation.

The formats option is an array in order of preferred formats for the template or layout you are interested in using. But formats do not equate to filename extensions. Instead, they equate to the ultimate content type that you want to render. For example: html, json, js, xml, etc. We may want to try something like this:

render_to_string(
  template: 'notifiers/base_notifier',
  formats: ['inky-haml', :html],
  layout: 'mailer'
)

But this will raise an error because inky-haml is not a format. But it is a handler.

SOLUTION: Use Handlers

render_to_string(
  template: 'notifiers/base_notifier',
  handlers: ['inky-haml'],
  layout: 'mailer'
)

… Although it isn’t documented, this works because installing the inky gem adds this handler to the allowed handlers array. Rails tries to determine the correct handler on it’s own, but sometimes it doesn’t work quite right, as in the case where you have multiple layouts or templates with similar names:

mailer.html.erb
mailer.text.erb
mailer.html.inky-haml

Now, go forth and render with confidence…

Cheers,

– Geeze

For reference, a list of formats will look something like this:

formats: [
  :atom,
  :bmp,
  :css,
  :csv,
  :doc,
  :doc,
  :docx,
  :docx,
  :gif,
  :gzip,
  :html,
  :ics,
  :jpeg,
  :js,
  :json,
  :m4a,
  :mp3,
  :mp4,
  :mpeg,
  :multipart_form,
  :ogg,
  :otf,
  :pdf,
  :pdf,
  :png,
  :rss,
  :svg,
  :text,
  :tiff,
  :ttf,
  :url_encoded_form,
  :vcf,
  :vtt,
  :webm,
  :woff,
  :woff2,
  :xls,
  :xlsx,
  :xml,
  :yaml,
  :zip
]

Handlers look like this:

handlers: [
  :"inky-axlsx",
  :"inky-builder",
  :"inky-caracal",
  :"inky-coffee",
  :"inky-erb",
  :"inky-haml",
  :"inky-html",
  :"inky-jbuilder",
  :"inky-prawn",
  :"inky-raw",
  :"inky-ruby",
  :axlsx,
  :builder,
  :caracal,
  :coffee,
  :erb,
  :haml,
  :html,
  :inky,
  :jbuilder,
  :prawn,
  :raw,
  :ruby
]