Contact us

TILs - Fueling Curiosity, One Insight at a Time

At Codemancers, we believe every day is an opportunity to grow. This section is where our team shares bite-sized discoveries, technical breakthroughs and fascinating nuggets of wisdom we've stumbled upon in our work.

Published
Author
user-image
Satya
slack events api performs the events within 3 seconds if any exception happens then it retries again when the app is mentioned again.
Published
Author
user-image
Satya
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
Published
Author
user-image
Sujay
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.
Published
Author
user-image
Ashwani Kumar Jha
Senior System Analyst

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:



Code

const transactions = [
 { account: 'savings', amount: 12, date: '2023-01-01' },
 { account: 'checking', amount: 200, date: '2023-01-01' },
 { account: 'savings', amount: 500, date: '2023-02-01' },
 { account: 'checking', amount: 300, date: '2023-02-01' },
];


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


Code

const groupedTransactions = Object.groupBy(transactions, ({ account }) => account);


The output will be:


Code

{
 savings: [
 { account: 'savings', amount: 12, date: '2023-01-01' },
 { account: 'savings', amount: 500, date: '2023-02-01' }
 ],
 checking: [
 { account: 'checking', amount: 200, date: '2023-01-01' },
 { account: 'checking', amount: 300, date: '2023-02-01' }
 ]
}

Published
Author
user-image
Rishav Raj
System Analyst
To see all commits on all branches that have not yet been pushed we can use this git cmd

Code

git log --branches --not --remotes

Published
Author
user-image
Sujay
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.
Published
Author
user-image
Sujay
Difference between dynamic and Object type in dart
dynamic : dynamic is incredibly flexible. It tells Dart compiler to skip the type checking at compile time while type checking happens at run time. This is helpful when working with data of uncertain types.


Code

dynamic value = 42;
value = 'Sujay';
print(value.isEven); // Error thrown during runtime



Object : Object is the root class for all other classes. Its like a container like that can hold any value. Since Object is generic, you won't have access to specific methods or properties of value without type casting


Code

Object value = 42;
print(value.isEven); // throws compile time error

Published
Author
user-image
Vaibhav Yadav
Senior System Analyst
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.
Published
Author
user-image
Ashwani Kumar Jha
Senior System Analyst
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.


Code

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.
Published
Author
user-image
Sujay
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


Code

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


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

Code

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


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

Showing 36 to 38 of 82 results

Ready to Build Something Amazing?

Codemancers can bring your vision to life and help you achieve your goals

Let's Talk