It became clear that the theme wasn’t available in the Open VSX registry, which is the only marketplace Antigravity can use by default. Due to licensing rules, Antigravity can't access the official Microsoft marketplace, so it couldn't download the extension automatically.

This left me with only one option: to install it manually.

Getting the VSIX File

Since the extension wasn't available in Open VSX, I obtained the .vsix package directly from VS Code. Once you have the VSIX file, Antigravity can easily install it locally. In my case, the file was:

hiteshchoudharycode.chai-theme-0.2.0-web.vsix

Installing the Extension Manually

Antigravity supports the same local extension installation process as VS Code. All you need is this command:

antigravity --install-extension hiteshchoudharycode.chai-theme-0.2.0-web.vsix

Right after that, you receive the confirmation:

Installing extensions...
Extension 'hiteshchoudharycode.chai-theme-0.2.0-web.vsix' was successfully installed.

Theme applied.

Final Notes

If an extension isn’t available in Open VSX, you can always:

1. Download the .vsix file

2. Install it manually

This method works and saves you from having to switch editors just for a theme or plugin.

https://github.com/yshmarov/moneygun/pull/286
First, I want to share that I learned about Yaroslav Shmarov (@yarotheslav) looking for contributors for their open-source product, Moneygun, through a Twitter post he made. I also wanted to explore the new version of the Noticed gem, so I decided to give it a try. That's how I got the opportunity to work on this issue.

Do check out Moneygun if you want to build your next B2B SaaS app (software as a service): https://github.com/yshmarov/moneygun

There are two things that need to be implemented.

• In-app notifications

• Email

First, I explored the gem to understand how to implement basic boilerplate code for notifications, then began by adding the gem to the Rails application:

# notifications
gem "noticed"

Or

Run the following command to add Noticed to your Gemfile:

bundle add "noticed"

Generate and then run the migrations:

rails noticed:install:migrations
rails db:migrate

To start, create a Notifier:

We have two requirements here:

1. The user should be notified when they are invited to an organization.

2. The user should be notified when their membership request is accepted.

rails generate noticed:notifier MembershipInvitationNotifier
rails generate noticed:notifier MembershipRequestAcceptedNotifier

In this post, we'll deliver notifications by email, and in the next post, we'll cover turbo_stream, which provides real-time UI updates to users' browsers.

First, let's take a look at how the generated notifier appears.

Three files are created under the notifiers:

# app/notifiers/application_notifier.rb
class ApplicationNotifier < Noticed::Event
end

# app/notifiers/membership_request_accepted_notifier.rb
# To deliver this notification:
#
# MembershipRequestAcceptedNotifier.with(record: @post, message: "New post").deliver(User.all)
class MembershipRequestAcceptedNotifier < ApplicationNotifier
 # Add your delivery methods
 #
 # deliver_by :email do |config|
 #   config.mailer = "UserMailer"
 #   config.method = "new_post"
 # end
 #
 # bulk_deliver_by :slack do |config|
 #   config.url = -> { Rails.application.credentials.slack_webhook_url }
 # end
 #
 # deliver_by :custom do |config|
 #   config.class = "MyDeliveryMethod"
 # end
 #
 # Add required params
 #
 # required_param :message
end

# app/notifiers/membership_invitation_notifier.rb
# To deliver this notification:
#
# MembershipInvitationNotifier.with(record: @post, message: "New post").deliver(User.all)
class MembershipInvitationNotifier < ApplicationNotifier
 # Add your delivery methods
 #
 # deliver_by :email do |config|
 #   config.mailer = "UserMailer"
 #   config.method = "new_post"
 # end
 #
 # bulk_deliver_by :slack do |config|
 #   config.url = -> { Rails.application.credentials.slack_webhook_url }
 # end
 #
 # deliver_by :custom do |config|
 #   config.class = "MyDeliveryMethod"
 # end
 #
 # Add required params
 #
 # required_param :message
end

In the boilerplate code, you can see there's⁣deliver_by: email, so we will implement the mailer delivery method first.

We won't complicate things for now; we'll start with one notifier to give you an idea, and then you can implement another notifier on your own.

So we need to notify the user when he is invited to an organization. First, clean up the commented lines and keep only the ones that are needed.

class MembershipInvitationNotifier < ApplicationNotifier
 # Add your delivery methods
 #
 # deliver_by :email do |config|
 #   config.mailer = "UserMailer"
 #   config.method = "new_post"
 # end
 #
 # Add required params
 #
 # required_param :message
end

Notifiers can use different helper methods. Inside a notification_methods block, we also set up the message and URL helpers.

notification_methods do
   # I18n helpers
   def message
     t(".message")
   end

   # URL helpers are accessible in notifications
   # Don't forget to set your default_url_options so Rails knows how to generate urls
   def url
     user_invitations_url
   end
 end

These helpers can be helpful when rendering a user’s notifications on the web.

<div>
  <% @user.notifications.each do |notification| %>
    <%= link_to notification.message, notification.url %>
  <% end %>
</div>

Calling the message helper in the ERB view will look for the following translation path:

# config/locales/en.yml
en:
 notifiers:
   membership_invitation_notifier:
     notification:
       message: You've been invited to join %{organization_name}

Notifiers can choose required parameters using the required_paramsmethod. We need to declare :organization as a required parameter to ensure params[:organization] is available in our notifier:

 required_params :organization

 def message
   t(".message", organization_name: params[:organization].name)
 end

In this case, we need the mailer, so generate it by running

rails generate mailer MembershipMailer invitation_email

# app/mailers/membership_mailer.rb
class MembershipMailer < ApplicationMailer
  # Subject can be set in your I18n file at config/locales/en.yml
  # with the following lookup:
  #
  #   en.membership_mailer.invitation_email.subject
  #
  def invitation_email
    @greeting = "Hi"
    mail to: "to@example.org"
  end
end

app/views/membership_mailer/invitation_email.text.erb

Membership#invitation_email

<%= @greeting %>, find me in app/views/membership_mailer/invitation_email.text.erb

Instead of using this default greeting, we want to send our message and include the action_url. To do this, we need to have the notification object available, so we should pass it from our notifier like this:

deliver_by :email do |config|
  config.mailer = "MembershipMailer"
  config.method = :invitation_email
  config.args   = -> { [ self ] }
end

Now we need to make a small change to our mailer method.

# app/mailers/membership_mailer.rb
class MembershipMailer < ApplicationMailer
  def invitation_email(notification)
    setup(notification)
    mail(to: @recipient.email, subject: t(".subject", organization_name: @organization.name))
  end

  private

  def setup(notification)
    @organization = notification.params[:organization]
    @message = notification.message
    @recipient = notification.recipient
    @action_url = notification.url
  end
end

# app/views/membership_mailer/invitation_email.text.erb
<%= @message %>

View your invitations: <%= @action_url %>

Now our notifier code looks like this:

class MembershipInvitationNotifier < ApplicationNotifier
  # Add your delivery methods
  deliver_by :email do |config|
    config.mailer = "MembershipMailer"
    config.method = :invitation_email
    config.args   = -> { [ self ] }
  end

  # Add required params
  required_params :organization

  notification_methods do
    # I18n helpers
    def message
      t(".message", organization_name: params[:organization].name)
    end

    # URL helpers are accessible in notifications
    # Don't forget to set your default_url_options so Rails knows how to generate urls
    def url
      user_invitations_url
    end
  end
end

Our notifier setup is now complete. Next, we need to trigger this notifier:

# app/models/membership.rb
class Membership < ApplicationRecord
  after_create :send_invitation_notification

  private

  def send_invitation_notification
    MembershipInvitationNotifier.with(organization: organization).deliver(user)
  end
end

With this setup in place, we have everything necessary to notify a user when they are invited to join an organization. Thank you for taking the time to read.

Getter and setter methods in Ruby provide a controlled way to access and modify the values of instance variables from outside the class. This helps maintain data integrity and adheres to the principle of encapsulation, which means hiding the internal state of an object and only exposing necessary parts.

What?

• Getter Methods: Allow reading the value of an instance variable.

• Setter Methods: Allow modifying the value of an instance variable.

How?
Ruby simplifies the creation of these methods with attr_accessor, attr_reader, and attr_writer.

• attr_reader: Generates only getter methods.

• attr_writer: Generates only setter methods.

• attr_accessor: Generates both getter and setter methods.

Example

class Product
  attr_reader :name     # Generates only a getter for `name`
  attr_writer :price    # Generates only a setter for `price`
  attr_accessor :stock  # Generates both getter and setter for `stock`

  def initialize(name, price, stock)
    @name = name
    @price = price
    @stock = stock
  end
end

product = Product.new("T-Shirt", 19.99, 10)
puts product.name        # Output: T-Shirt (using getter)
product.price = 24.99    # No getter for `price`, but setter allows modification
product.stock = 5        # Both getter and setter available for `stock`

Listing Instance Variables and Methods

Ruby provides built-in methods to inspect an object's instance variables and methods:

• #instance_variables: Returns a list of instance variables.

• #public_methods: Returns a list of public methods.

p product.instance_variables  # Output: [:@name, :@price, :@stock]
p product.public_methods      # Output: List of public methods, including `name`, `price=`, and `stock`

By using these tools, you can better understand the structure and capabilities of your objects.

Recently, I read something called “The aggregation of marginal gains” from Atomic Habits by James Clear, which means searching for tiny margins of improvement in everything you do.

Well then, let’s see how you can improve how you learn programming. What’s the best way to learn programming?

Watching tutorials on a specific topic on YouTube?

Reading articles?

Blog posts?

Books?

Or is it just simply coding 24x7?

Well, the best way to learn programming is, teaching and building Projects. I said it right.

Let’s talk about how can “teaching” help you learn programming a lot faster…

Teaching Programming:

A lot of you might have already heard about this method of learning –

Learning by teaching others.

Even studies have been done to prove this method works. Sounds a little crazy, but recall an incident in school or college where you couldn’t understand a specific topic or subject, you asked your friend who scores well in that subject and he explained it to you and you understood.

You might be wondering why he scores better than you, though both of you are putting a lot of effort into learning?

The reason for his success is because he has understood the topic to a level, where he could teach it to others. That’s the level of understanding you need.

How can I learn to get to that level in programming?

Well, it’s the same concept. If you learn something new, teach it to someone else. That would help you retain what you learned for a very long time and also solve misconceptions you had.

How do you teach? 🤔

Well, this had been a problem for many of us for a very long time. I’ve heard and knew about this study on how teaching can help you in learning but I’ve always thought, how do I teach and to whom?

I thought I must teach my friends at school or college, etc. But the reality is, you don’t need to.

You can literally teach to anyone around the world, and make yourself better in the subject.

You can write an article on Medium, shoot a video for YouTube, tutor someone online, or even do pair programming…

Building Projects:

Concepts are easy to forget unless you apply them in real life. Building projects are kinda more related to programming.

Learned about how to create objects in JavaScript? Learned how to fetch data from an API?

Create a small project, upload your code to GitHub, write an article, make a post or make a video and publish (be open to critics.)

How can I apply this in my day-to-day life?

Whenever you learn something new in programming or really about anything, teach it to a friend (probably someone who would be interested in it. 😅), record a video, make a post on Instagram, or at least write an article on Medium about it.

Prerequisites

Before we begin, ensure that you have curl and git installed on your system. You can install them using the following command:

sudo apt install curl git

Step 1: Clone the asdf Repository

First, clone the asdf repository from GitHub into your home directory:

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.14.0

This command checks out the version 0.14.0 of asdf. Adjust the version number as needed.

Step 2: Update Your Shell Configuration

To make asdf available in your terminal, you need to update your shell configuration. Add the following lines to your ~/.bashrc file:

. "$HOME/.asdf/asdf.sh"
. "$HOME/.asdf/completions/asdf.bash"

After adding these lines, reload your ~/.bashrc file to apply the changes:

source ~/.bashrc

Step 3: Install Node.js

To install Node.js using asdf, follow these steps:

Install Additional Dependencies

Node.js requires some additional dependencies which can be installed using the following command:

sudo apt-get install dirmngr gpg curl gawk

Add the Node.js Plugin

Next, add the Node.js plugin to asdf:

asdf plugin add nodejs https://github.com/asdf-vm/asdf-nodejs.git

Install the Latest Version of Node.js

You can now install the latest version of Node.js:

asdf install nodejs latest

Step 4: Install Ruby

To install Ruby using asdf, follow these steps:

Add the Ruby Plugin

First, add the Ruby plugin to asdf:

asdf plugin add ruby https://github.com/asdf-vm/asdf-ruby.git

Install the Latest Version of Ruby

Now, you can install the latest version of Ruby:

asdf install ruby latest

Step 5: Verify the Installation

It's important to verify that asdf has correctly installed and configured the runtime versions. You can do this by checking the output of the type -a ruby command.

• Correct Output:

    ruby is /home/username/.asdf/shims/ruby
    ruby is /usr/bin/ruby
  

• Incorrect Output:

    ruby is /usr/bin/ruby
  

If you see the correct output, it means that asdf is correctly managing the Ruby version.

Conclusion

By following these steps, you've installed asdf and configured it to manage Node.js and Ruby on your system. This setup will help you seamlessly switch between different versions of these runtimes, making your development environment more flexible and efficient.

Happy coding!

Feel free to ask any questions in the comments below or share your experience using asdf to manage different runtime versions. If you found this article helpful, don't forget to give it a thumbs up and share it with your network!

1. Git and Github

Git and GitHub are two of the most important tools every developer should know. They help you handle version control for your websites and applications.

2. Chrome Dev Tools

Chrome Dev Tools is a set of tools that come directly into the browser. It helps web developers edit pages and identify bugs in the browser to help build better websites faster.

3. Oh My Zsh

Oh My Zsh is an open-source framework to manage your shell configuration. It will help you become a 10x developer.

4. Postman

Postman helps you build API's, test them, and receive data from API's. If you want to see what data you receive from an API, Postman makes it all easy.

5. Vercel

Vercel is a cloud platform similar to Netlify. It simplifies the way you host your project. Your deployment is just one git push away!

6. Notion

Everybody loves. Who doesn't? Notion is an all-in-one place to get your notes, to-dos, ideas, and everything else organized. It works like your second brain.

Do you use these tools every day as a developer? Did you learn something new today? Let me know what you think in the comments.

Please do share with your friends and community so that it might help others.
Follow for more such content, and do check out my profile.

1. Integrated Development Environments (IDEs):

- Visual Studio Code: A popular, lightweight, and extensible IDE with powerful features, extensive language support, and a vibrant community.

- JetBrains IntelliJ IDEA: A robust IDE that offers smart code completion, code navigation, debugging, and version control integration.

2. Version Control Systems:

- Git: A distributed version control system that enables collaboration, code versioning, branching, and merging.

- GitHub: A web-based platform that provides Git repository hosting, issue tracking, code review, and collaboration features.

- Bitbucket: Another web-based platform that offers Git and Mercurial repository hosting with built-in CI/CD and issue tracking capabilities.

3. Collaboration and Communication Tools:

- Slack: A team communication platform that allows real-time messaging, file sharing, and integration with various development tools.

- Microsoft Teams: A collaboration hub that combines chat, video meetings, file sharing, and integration with other Microsoft products.

- Jira: A popular project management tool for agile development, enabling issue tracking, task management, and team collaboration.

4. Continuous Integration and Deployment (CI/CD) Tools:

- Jenkins: An open-source automation server that facilitates building, testing, and deploying software.

- CircleCI: A cloud-based CI/CD platform that automates the software development process with seamless integration and scalability.

- Travis CI: A popular CI/CD tool that supports various programming languages and integrates well with GitHub repositories.

5. Task and Project Management Tools:

- Trello: A visual collaboration tool that helps organize and track tasks using boards, lists, and cards.

- Asana: A flexible project management tool that enables teams to plan, track progress, and communicate about tasks and projects.

- Monday.com: An intuitive work management platform that provides customizable workflows, task tracking, and collaboration features.

6. Documentation Tools:

- Confluence: A team collaboration and knowledge sharing platform that allows creating, organizing, and documenting project information.

- Markdown Editors (e.g., Visual Studio Code with Markdown extensions): Lightweight editors that simplify writing and formatting documentation in Markdown syntax.

7. Testing and Debugging Tools:

- Selenium: A web automation tool for testing web applications across multiple browsers and platforms.

- Postman: A popular API development and testing platform that simplifies API testing, documentation, and collaboration.

- Chrome DevTools: A set of web developer tools built into the Google Chrome browser, offering debugging, profiling, and performance analysis capabilities.

Remember, the choice of tools may vary depending on your specific requirements, programming language, and team preferences. It's essential to explore and experiment with different tools to find the ones that best suit your workflow and boost your productivity as a software developer.

Once the chef completes the meal, the waiter brings the meal to the customer.

Similarly,

An API receives a request from an application.

Then it interacts with a data source to collect and process a response,

Which is then returned to the application.

📓Definition :-

An API (Application Programming Interface) is a set of functions that allows applications to access data and interact with external software components, operating systems, or microservices.

#programming #software #operatingsystems #data #microservices #chef