Fueling Curiosity, One Insight at a Time

When running a javascript/typescript file during build time that requires environment variables importing dotenv config gets the job done. Alternate approach is to have values in package.json that goes against the idea of having the environment variables as secrets and hidden from the repository code.

In a web application, there can be scenarios where certain data needs to be fetched conditionally. For eg, in application with multiple user roles, there might be a specific role for which certain data is not needed. In such a case, we might want to avoid making unnecessary API calls to fetch that data. However, due to React's rules of hooks, we cannot directly conditionally call a hook which fetches data.

If you're using a library like react-query and if you do not want to create a wrapper component to fetch the data, react-query provides a good solution. react-query has an enabled option for its useQuery hook. We can conditionally enable or disable the query based on our needs.

const { data, isLoading } = useQuery(
 ['user', userId], 
 fetchUserData, 
 { enabled: isAuthenticated }
);

Here the useQuery is only executed if isAuthenticated is true. If isAuthenticated is false, the query is skipped.

Use environmental variables in flutter

- Install flutter_dotenv package
- Create a .env file in the root of your project
- Add your variables to the .env file
- In order for the package to load .env file, add it to asset bundle in pubspec.yaml

  flutter:
    assets:
      - .env (path to the file where env is stored)

- Load the contents of env into flutter, by adding this is main.dart

 void main() async {
    await dotenv.load();
    runApp(const MyApp());
  }

- Access the env variable like this dotenv.env['APP_ENVIRONMENT']

below are the generator helper methods used to perform various actions in files and directories
• copy_file
• create_file
• insert_into_file
• inside
• gsub_file

generate generator by doing bin/rails generate generator initializer .
This will create the below files for you

create  lib/generators/initializer
create  lib/generators/initializer/initializer_generator.rb
create  lib/generators/initializer/USAGE
create  lib/generators/initializer/templates
create  spec/generator/initializers_generator_spec.rb

Slack apps best practices and User experience - https://api.slack.com/best-practices

How we can Set up Puma as Systemd service in Ubuntu 18 for Rails application, The main purpose is ,
• to ensure it starts automatically on boot,
• can be managed easily with systemd's service management commands,
• It also allows for better process management, automatic restarts in case of failure, and logging capabilities,
• few set of commands used to create puma.service file and getting it started:
for file creation : /etc/systemd/system/puma.service
sudo systemctl daemon-reload
sudo systemctl enable puma
sudo service puma start
sudo service puma status

Retrieving Command History with FZF
Command: To view the command history, we can use the following command:
history | fzf
Note: Ensure that you have FZF installed before. It provides an efficient way to navigate through past commands.

Components:
Components are user interface elements that can be reused throughout the design file. They make design more consistent and allow for more rapid modifications.
Components can be made from a layer , groups or frames.

• Generally, there are two sorts of components:
1. Main Component: It is normally built first and is responsible for specifying several UI styles in the UI element.
2. Instance Component: This is the single occurrence main component.
When the main component is modified. It is automatically applied to the instance component. However, modifications to Instance components must be made manually.

The changes we make to the instance component are referred to as override. When we override an instance component and afterwards make modifications to the main component, the override does not change.

Lambda
A lambda is a way to define a block & its parameters with some special syntax.
You can save this lambda into a variable for later use.
The syntax for defining a Ruby lambda looks like this:

say_something = -> { puts "This is a lambda" }