TILs - Fueling Curiosity, One Insight at a Time

we need to add chat:write scope in bot token scopes, so that our bot can send messages in the channel when it is mentioned.

with modern Sign in with Slack we need to request the OpenID scopes—openid, email, and profile.

writing integration specs using RSpec and Capybara.

we need to add the user scopes email & profile when we are using the slack openid.connect.userInfo api method.

slack events api performs the events within 3 seconds if any exception happens then it retries again when the app is mentioned again.

we can use event subscription in our slack app to listen to events like mentioning the app and then the app will perform the action based on the event. For eg: like the way i did here.
For more info , please refer to -> https://api.slack.com/apis/connections/events-api

In Dart, metadata provides additional information about the code. It begins with the character @ followed by either a reference to a compile-time constant or a call to a constant constructor.

There are four commonly used annotations in Dart:

@Deprecated: This is used to indicate that a feature/method/class is deprecated and should not be used because it will be removed in future versions.
@deprecated: This is similar to @Deprecated, with the difference being that a message can be passed with @Deprecated.
@override: This is used to indicate that a method is intended to override a method from a superclass.
@pragma: This is used to provide additional information to the Dart compiler.

The groupBy method introduced in ES12 can be used to group elements based on the values returned by the specified callback function. This can be useful when we want to categorize items into distinct groups.

For example, consider a list of transactions and we want to group them by the account type:





We can use groupBy to group these transactions by their account type:




The output will be:

To see all commits on all branches that have not yet been pushed we can use this git cmd

In Flutter, widgets are the building blocks of your UI (similar to components in React), and there are mainly 3 type of widgets based on how they handle state: Stateless, Stateful, and Inherited widgets

Stateless Widgets:
- Stateless widgets are immutable i.e. their configuration cannot change once they are created. They represent parts of your UI that don't depend on any mutable state.
- Stateless widgets rebuild when their parent widget or the widget hierarchy above them rebuilds and when an Inherited widget it depends on changes

Stateful Widgets:
- Stateful widgets are mutable and holds some internal state that can change over time. They are used when a part of your UI depends on dynamic data or user interactions.
- Stateful widgets rebuild when their internal state changes. State updates are handled using setState() which also triggers a rebuild of the widget and its subtree. They can also rebuild when their parent widget or the widget hierarchy above them rebuilds.

Inherited Widgets:
- Inherited widgets are a special type of widget used to share data or state across an entire widget subtree without having to pass the data explicitly to every widget in the subtree (concept of Inherited widget is similar to Context API in React)
- Whenever the value inside Inherited widget changes, the widgets dependent on this widget get rebuilt.