DEV Community: Abhijeet Gavali

Running MySQL Server in Docker

Abhijeet Gavali — Wed, 23 Oct 2024 12:16:25 +0000

no theory

Check docker if installed

docker version

Download MySQL server image

docker pull mysql/mysql-server

Run MySQL Server container

docker run --name='sql_container' -d -p 3306:3306 mysql/mysql-server

Check Logs and copy root password generated by MySQL Server

docker logs sql_container

Go in bash and update the root password to simple password

docker exec -it sql_container bash

cd /var/lib/mysql

mysql -u root -p

ALTER USER 'root'@'localhost' IDENTIFIED BY 'password';

Create new user for accessing db \ Root access not recomendade

CREATE USER 'user'@'%' IDENTIFIED BY 'passwod';

GRANT ALL PRIVILEGES ON *.* TO 'user'@'%' WITH GRANT OPTION;

FLUSH PRIVILEGES;

Now Connect Using Workbench

host = localhost

port = 3306

user_name = user

user_password = password

I fount codecrafters.io

Abhijeet Gavali — Tue, 08 Oct 2024 09:01:27 +0000

Recently, I stumbled upon CodeCrafters, and I must say—it's amazing! If you're someone who enjoys challenging yourself with hands-on projects, you’ll love it. At CodeCrafters, you can dive deep into practical, out-of-the-box projects like building Redis, creating your own DNS server, or even developing low-level systems that help you understand how core technologies really work.

Currently, I'm working on building my own DNS server, and this project has given me a solid understanding of how DNS operates behind the scenes. From managing DNS requests to exploring the protocol in detail, I've gained insights that I wouldn't have gotten from theory alone. It’s a satisfying and eye-opening experience to reconstruct something we use every day!

It gives you the building blocks to figure things out on your own, which makes the learning process much more rewarding.

Here are a few reasons why I highly recommend checking them out:

Real-world project experience: You’re not just learning concepts; you're applying them to build something functional and real.
Step-by-step guidance: Each project comes with structured guidance, which makes challenging tasks more approachable.

Whether you're a developer looking to level up your skills or someone who's curious about how the web and its infrastructure work, CodeCrafters is an excellent platform to explore.

If you’re ready to take on the challenge, I highly recommend checking them out here. You won’t be disappointed!

Pro Tip: Start small and work your way up. With projects ranging from beginner-friendly to advanced, there's something for every skill level.

Happy coding!

Note: I’ll be creating a detailed blog on building and hosting the DNS server soon, so stay connected for more updates!

🌟 Hacktoberfest 2024 Has Begun! 🌟

Abhijeet Gavali — Tue, 01 Oct 2024 06:49:11 +0000

Hey Devs! 🚀

The most exciting time of the year for open-source lovers is here—Hacktoberfest 2024 has officially started! 🎉 I'm diving into my first contribution by tackling issues on the FreeCodeCamp Github. It's a fantastic way to give back to the community while sharpening those coding skills.

If you're participating this year too, I'd love to hear about it! Let me know in the comments which projects you're contributing to, and let’s cheer each other on as we build amazing things together!

✨ Struggling to find a project? No worries! Use this link to find GitHub projects participating in Hacktoberfest for the JavaScript language. You can easily change the language filter to match your preferred programming language too!

Happy hacking! 💻✨

🚀 Seeking Validation for a No-Code Landing Page Solution!

Abhijeet Gavali — Fri, 27 Sep 2024 08:56:37 +0000

As the demand for quick and versatile web solutions grows, I’m exploring the concept of a no-code tool that empowers users to create lightweight, SEO-optimized landing pages effortlessly. This tool is designed not just for idea validation but also for any scenario that requires a single landing page. I’d love to gather feedback from the community before moving forward!

Proposed Key Features:

Drag-and-Drop Builder: Users can easily add elements like text, images, and buttons with a simple drag-and-drop interface—no coding required!
Community-Built Templates: A wide range of customizable templates created by the community for various use cases, ensuring users have plenty of options to choose from.
Few-Click Launch: Users can select a template, upload necessary details and assets, and launch their landing page in just a few clicks. This streamlined process minimizes effort and accelerates deployment.
SEO Optimization: Automatic generation of SEO metadata to ensure landing pages are optimized for search engines, enhancing visibility and attracting potential visitors.
Lead Capture & Analytics: Integrated lead capture forms to collect valuable information from visitors, paired with analytics to track engagement and optimize future iterations.

Use Cases:
This tool serves as a one-page builder for various needs, including:

Product Wishlist: Create a landing page to gather interest and pre-orders for an upcoming product.
Event Registration: Set up a simple registration page for meetups, workshops, or webinars, especially those hosted on platforms like Discord.
Community Engagement: Build a page to facilitate sign-ups and information sharing for specific communities or initiatives.
Launch Announcements: Easily create landing pages to announce and showcase new products or services.

The Challenge:
Building a full website for every new initiative can be time-consuming and often unnecessary. By focusing on minimalistic landing pages, we aim to simplify the process for anyone needing a single page to convey information or collect registrations.

Your Thoughts?
I’m eager to hear your feedback on this concept!

Does this resonate with your experience?
What features do you think are essential for a no-code landing page tool?
Are there any pain points you’ve encountered in creating single-page solutions that this could address?
Your insights would be invaluable in shaping this idea into a tool that truly meets the needs of its users.

Thank you for your support!

🌟 I'm Joining Hacktoberfest 2024! 🌟

Abhijeet Gavali — Fri, 27 Sep 2024 06:14:07 +0000

Hey everyone! I'm joining the Hacktoberfest this year, and I’m super excited to dive in and make the most of it! 🎉

As a beginner, I’ll be sharing my journey, learnings, and resources here. If you're new too or have any questions about the fest, feel free to ask! I’ll do my best to help with everything I know and learn along the way.

Let’s grow together and make the most out of this amazing experience! 🚀

sppu-practical

Abhijeet Gavali — Tue, 23 Apr 2024 18:48:54 +0000

cuda mat mul

#include <cuda_runtime.h>
#include <iostream>

__global__ void matmul(int* A, int* B, int* C, int N) {
    int Row = blockIdx.y*blockDim.y+threadIdx.y;
    int Col = blockIdx.x*blockDim.x+threadIdx.x;
    if (Row < N && Col < N) {
        int Pvalue = 0;
        for (int k = 0; k < N; k++) {
            Pvalue += A[Row*N+k] * B[k*N+Col];
        }
        C[Row*N+Col] = Pvalue;
    }
}

int main() {
    int N = 512;
    int size = N * N * sizeof(int);
    int* A, * B, * C;
    int* dev_A, * dev_B, * dev_C;
    cudaMallocHost(&A, size);
    cudaMallocHost(&B, size);
    cudaMallocHost(&C, size);
    cudaMalloc(&dev_A, size);
    cudaMalloc(&dev_B, size);
    cudaMalloc(&dev_C, size);

    // Initialize matrices A and B
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            A[i*N+j] = i*N+j;
            B[i*N+j] = j*N+i;
        }
    }

    cudaMemcpy(dev_A, A, size, cudaMemcpyHostToDevice);
    cudaMemcpy(dev_B, B, size, cudaMemcpyHostToDevice);

    dim3 dimBlock(16, 16);
    dim3 dimGrid(N/dimBlock.x, N/dimBlock.y);

    matmul<<<dimGrid, dimBlock>>>(dev_A, dev_B, dev_C, N);

    cudaMemcpy(C, dev_C, size, cudaMemcpyDeviceToHost);

    // Print the result
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            std::cout << C[i*N+j] << " ";
        }
        std::cout << std::endl;
    }

    // Free memory
    cudaFree(dev_A);
    cudaFree(dev_B);
    cudaFree(dev_C);
    cudaFreeHost(A);
    cudaFreeHost(B);
    cudaFreeHost(C);

    return 0;
}

cuda vec add

// program 2 

#include <iostream>  
#include <cuda_runtime.h>

using namespace std;

__global__ void addVectors(int* A, int* B, int* C, int n) 
{
    int i = blockIdx.x * blockDim.x + threadIdx.x; 
    if (i < n) 
    {
        C[i] = A[i] + B[I];
    }
}

int main() 
{
    int n = 1000000;  
    int* A, * B, * C;
    int size = n * sizeof(int);

    // Allocate memory on the host  
    cudaMallocHost(&A, size);  
    cudaMallocHost(&B, size);  
    cudaMallocHost(&C, size);

    // Initialize the vectors
    for (int i = 0; i < n; i++) 
    {
        A[i] = I;
        B[i] = i * 2;
    }
    // Allocate memory on the device  
    int* dev_A, * dev_B, * dev_C;  
    cudaMalloc(&dev_A, size);  
    cudaMalloc(&dev_B, size);  
    cudaMalloc(&dev_C, size);

    // Copy data from host to device
    cudaMemcpy(dev_A, A, size, cudaMemcpyHostToDevice);  
    cudaMemcpy(dev_B, B, size, cudaMemcpyHostToDevice);

    // Launch the kernel  
    int blockSize = 256;
    int numBlocks = (n + blockSize - 1) / blockSize;
    addVectors<<<numBlocks, blockSize>>>(dev_A, dev_B, dev_C, n);

    // Copy data from device to host
    cudaMemcpy(C, dev_C, size, cudaMemcpyDeviceToHost);

    // Print the results
    for (int i = 0; i < 10; i++) 
    {
        cout << C[i] << " ";
    }
    cout << endl;

    // Free memory  
    cudaFree(dev_A);  
    cudaFree(dev_B);  
    cudaFree(dev_C);  
    cudaFreeHost(A);  
    cudaFreeHost(B);  
    cudaFreeHost(C);

    return 0;
}

cpp bfs dfs

#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <omp.h>

using namespace std;

class Graph {
    int V;
    vector<vector<int>> adjList;

public:
    Graph(int V) {
        this->V = V;
        adjList.resize(V);
    }

    void addEdge(int src, int dest) {
        adjList[src].push_back(dest);
        adjList[dest].push_back(src); // For undirected graph
    }

    vector<int> getNeighbors(int vertex) {
        return adjList[vertex];
    }
};

void parallelBFS(Graph& graph, int source, vector<bool>& visited) {
    queue<int> q;
    q.push(source);
    visited[source] = true;

    while (!q.empty()) {
        int current = q.front();
        q.pop();
        cout << "Visited: " << current << endl;

        vector<int> neighbors = graph.getNeighbors(current);
        #pragma omp parallel for
        for (int i = 0; i < neighbors.size(); ++i) {
            int neighbor = neighbors[i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                q.push(neighbor);
            }
        }
    }
}

void parallelDFS(Graph& graph, int source, vector<bool>& visited) {
    stack<int> s;
    s.push(source);
    visited[source] = true;

    while (!s.empty()) {
        int current = s.top();
        s.pop();
        cout << "Visited: " << current << endl;

        vector<int> neighbors = graph.getNeighbors(current);
        #pragma omp parallel for
        for (int i = 0; i < neighbors.size(); ++i) {
            int neighbor = neighbors[i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                s.push(neighbor);
            }
        }
    }
}

int main() {
    int V, E;
    cout << "Enter the number of vertices: ";
    cin >> V;
    Graph graph(V);
    cout << "Enter the number of edges: ";
    cin >> E;
    cout << "Enter the edges (src dest):" << endl;
    for (int i = 0; i < E; ++i) {
        int src, dest;
        cin >> src >> dest;
        graph.addEdge(src, dest);
    }

    vector<bool> visited(V, false);

    cout << "Parallel BFS:" << endl;
    #pragma omp parallel num_threads(2)
    {
        #pragma omp single nowait
        parallelBFS(graph, 0, visited);
    }

    // Reset visited array for DFS
    fill(visited.begin(), visited.end(), false);

    cout << "Parallel DFS:" << endl;
    #pragma omp parallel num_threads(2)
    {
        #pragma omp single nowait
        parallelDFS(graph, 0, visited);
    }

    return 0;
}

Boston

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Flatten
from sklearn import preprocessing

(X_train, Y_train), (X_test, Y_test) = keras.datasets.boston_housing.load_data()

print("Training data shape:", X_train.shape)
print("Test data shape:", X_test.shape)
print("Train output data shape:", Y_train.shape)
print("Actual Test output data shape:", Y_test.shape)

##Normalize the data

X_train=preprocessing.normalize(X_train)
X_test=preprocessing.normalize(X_test)

#Model Building

X_train[0].shape
model = Sequential()
model.add(Dense(128,activation='relu',input_shape= X_train[0].shape))
model.add(Dense(64,activation='relu'))
model.add(Dense(32,activation='relu'))
model.add(Dense(1))

model.summary()

model.compile(loss='mse',optimizer='rmsprop',metrics=['mae'])

history = model.fit(X_train,Y_train,epochs=100,batch_size=1,verbose=1,validation_data=(X_test,Y_test))

results = model.evaluate(X_test, Y_test)
print(results)

fashion

from tensorflow import keras
import numpy as np 
import matplotlib.pyplot as plt 

fashion_mnist = keras.datasets.fashion_mnist
(train_img, train_labels), (test_img, test_labels) = fashion_mnist.load_data()

train_img = train_img / 255.0
test_img = test_img / 255.0

model = keras.Sequential([keras.layers.Flatten(input_shape=(28, 28)), 
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', 
    metrics=['accuracy'])

model.fit(train_img, train_labels, epochs=10)

test_loss, test_acc = model.evaluate(test_img, test_labels)
print("accuracy of tessting: ",test_acc)

predictions = model.predict(test_img)

predicted_labels = np.argmax(predictions, axis=1)

num_rows = 5 
num_cols = 5
num_imgs = num_rows*num_cols

plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_imgs):
    plt.subplot(num_rows, 2*num_cols, 2*i+1)
    plt.imshow(test_img[1], cmap='gray')
    plt.axis("off")
    plt.subplot(num_rows, 2*num_cols, 2*i+2)
    plt.bar(range(10), predictions[i])
    plt.xticks(range(10))
    plt.ylim([0,1])
    plt.tight_layout()
    plt.title(f"predicted_labels: {predicted_labels[i]}")
    plt.show()

imdb

from  keras.datasets import imdb

(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)

max([max(sequence) for sequence in train_data])


word_index = imdb.get_word_index()
reverse_word_index = dict([(val, key) for (key, val) in word_index.items()])
decoded_review = ' '.join([reverse_word_index.get(i-3, '?') for i in train_data[0]])

import numpy as np

def vectorize(sequences, dimension=10000): 
        results = np.zeros((len(sequences), dimension))
        for i, sequence in enumerate(sequences):
            results[i, sequence] = 1
        return results

x_train = vectorize(train_data)
x_test = vectorize(test_data)
y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')


from keras import models
from keras import layers

model = models.Sequential()
model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(16, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))


model.compile(loss = 'binary_crossentropy',optimizer='rmsprop',  metrics = ['accuracy'])


x_val = x_train[:10000]
y_val = y_train[:10000]

partial_x = x_train[10000:]
partial_y = y_train[10000:]


history = model.fit(partial_x, partial_y, epochs=20, batch_size=512, validation_data=(x_val, y_val))
results = model.evaluate(x_test, y_test)
print(results)

min-max cpp

#include <iostream>
#include <vector>
#include <omp.h>
#include <climits>

using namespace std;

void min_reduction(vector<int>& arr) {
  int min_value = INT_MAX;
  #pragma omp parallel for reduction(min: min_value)
  for (int i = 0; i < arr.size(); i++) {
    if (arr[i] < min_value) {
      min_value = arr[i];
    }
  }
  cout << "Minimum value: " << min_value << endl;
}

void max_reduction(vector<int>& arr) {
  int max_value = INT_MIN;
  #pragma omp parallel for reduction(max: max_value)
  for (int i = 0; i < arr.size(); i++) {
    if (arr[i] > max_value) {
      max_value = arr[i];
    }
  }
  cout << "Maximum value: " << max_value << endl;
}

void sum_reduction(vector<int>& arr) {
  int sum = 0;
   #pragma omp parallel for reduction(+: sum)
   for (int i = 0; i < arr.size(); i++) {
    sum += arr[i];
  }
  cout << "Sum: " << sum << endl;
}

void average_reduction(vector<int>& arr) {
  int sum = 0;
  #pragma omp parallel for reduction(+: sum)
  for (int i = 0; i < arr.size(); i++) {
    sum += arr[i];
  }
  cout << "Average: " << (double)sum / arr.size() << endl;
}

int main() {
  vector<int> arr;
  arr.push_back(5);
  arr.push_back(2);
  arr.push_back(9);
  arr.push_back(1);
  arr.push_back(7);
  arr.push_back(6);
  arr.push_back(8);
  arr.push_back(3);
  arr.push_back(4);

  min_reduction(arr);
  max_reduction(arr);
  sum_reduction(arr);
  average_reduction(arr);
}

sorting

#include <iostream>
#include <vector>
#include <cstdlib>
#include <omp.h>

// Function to perform bubble sort
void bubbleSort(std::vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                std::swap(arr[j], arr[j+1]);
            }
        }
    }
}

// Function to merge two sorted subvectors
void merge(std::vector<int>& arr, int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;

    std::vector<int> L(n1), R(n2);

    for (int i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];

    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

// Function to perform merge sort
void mergeSort(std::vector<int>& arr, int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;

        #pragma omp parallel sections
        {
            #pragma omp section
            mergeSort(arr, l, m);
            #pragma omp section
            mergeSort(arr, m + 1, r);
        }

        merge(arr, l, m, r);
    }
}

// Function to print a vector
void printVector(const std::vector<int>& arr) {
    for (int num : arr)
        std::cout << num << " ";
    std::cout << std::endl;
}

int main() {
    int n = 10000; // Size of vector
    std::vector<int> arr(n), arr_copy(n);

    // Initialize vector with random values
    srand(42);
    for (int i = 0; i < n; i++) {
        arr[i] = rand() % 10000;
        arr_copy[i] = arr[i];
    }

    std::cout << "Original vector:" << std::endl;
    printVector(arr);

    // Sequential bubble sort
    double start = omp_get_wtime();
    bubbleSort(arr);
    double end = omp_get_wtime();
    std::cout << "\nSequential Bubble Sort: " << end - start << " seconds" << std::endl;
    //printVector(arr);

    // Parallel merge sort
    start = omp_get_wtime();
    mergeSort(arr_copy, 0, n - 1);
    end = omp_get_wtime();
    std::cout << "\nParallel Merge Sort: " << end - start << " seconds" << std::endl;
    //printVector(arr_copy);

    return 0;
}

Should You schedule tweet ?

Abhijeet Gavali — Tue, 05 Sep 2023 14:38:58 +0000

You probably know the power of Twitter if you're serious about using social media to promote your brand or business. When it comes to contacting your target audience and interacting with your followers, Twitter may be a game-changer because to its millions of active users and its real-time nature.

But it might be challenging to keep up with Twitter's hectic environment. Your material may easily get buried in the cacophony as there are thousands of tweets made every minute. Because of this, scheduling your tweets in advance might be a wise technique to maximize your influence on Twitter by posting your tweets at the appropriate time, dispersing them throughout the day, and saving you time posting.

Here are the exact steps for scheduling your tweets, the benefits of doing so, and some advice on how to post to Twitter efficiently.

How to schedule tweets on Twitter

You can schedule tweets right within Twitter. Here’s how:

Log in to the Twitter app or website. Choose 'Tweet' from the menu on the left side of the page, then type your message.
Enter the information you want to tweet there.
Instead of sending sending, click the calendar button.
Select the day and time when you want your tweet to be sent.
To schedule your tweet, click the "confirm" button. Your tweet has been scheduled for the date and time you specified.

Every time you schedule a tweet, you have to choose the day and time, which makes it a very laborious procedure. Fortunately, there are many tools available that make it simpler to plan tweets along with your other social media material.

How to schedule tweets with HYPEFURRY

Hypefury is quite simple to use; all you have to do is register for an account to get started. Even better, you could get started scheduling tweets by creating a free trial and learning more about the features of the subscription plan!

You'll arrive at the dashboard after logging in with your Twitter credentials and be able to start creating the premium content your followers will adore right away.

Click on “What would you like to share?”
You can create a post by using the composer that will appear.
After you've finished writing your post, you may decide when and where to share it.

Tip: If you wish to post to Twitter directly, save the post to your draughts, or put it to your queue of tweets, scroll to the bottom of the composer once you've set your time.

By selecting "Compose a Draught" and writing your article, you may also choose to schedule tweets from the draughts tab. When you're finished, simply store the draught for later or put it in your queue of tweets that are ready to be posted.

Additionally, you have the option to use the Insta-shot feature to share your post on Instagram.

Should you schedule tweets or post natively?

When it comes to how your tweets perform, scheduling or posting them makes little difference, so it's truly a personal choice.

Scheduling your social media postings ahead of time is an excellent strategy to:

Maintain consistency.
Posting when your audience is online.
Grouping your tasks.
Enable you to make advance plans.

However, blogging natively can be a terrific method to be in real-time contact with your followers if you value spontaneity. The choice of approach depends ultimately on your objectives and target audience.

Why should you schedule tweets?

There are a lot of great reasons to schedule your tweets in advance!

1. Scheduling tweets ensures quality and consistency
You may ensure that you're maintaining a regular posting schedule by scheduling your material in advance. As a result of your continued presence, your audience will start to trust you more, which helps you stay on top of your social media strategy.

If you want to utilize Twitter to amplify a future campaign, scheduling tweets is also a terrific idea. All of your tweets can be written and scheduled in advance while your campaign is being planned. You won't need to worry about your social media efforts on launch day because your tweets will be uploaded successfully at the timings you specify.

2. Scheduling tweets allows you to reach a wider audience
Scheduling tweets is another excellent approach to ensure that your material reaches the widest possible audience. By scheduling tweets at different times of the day, you may reach audiences in different time zones and begin to understand the optimal time to send your tweets, which will help you enhance your engagement and reach on Twitter.

3. Scheduling tweets lets you batch your work and plan in advance
If you're trying to expand your Twitter account, it's a good idea to tweet one to five times every day. But that's just Twitter; most individuals also post to Instagram, LinkedIn, TikTok, and other platforms on a daily basis. Manually posting to social media is doable, but it can consume a significant amount of your productivity and time in a day.

You may plan out your content to be posted without having to manually post the tweet by scheduling it. You can also create batch content by writing several days or weeks' worth of tweets at once, scheduling them, and focusing on engaging rather than creating new material every day.

Scheduling also allows you to plan ahead of time. You can check an upcoming social media calendar to see if there are any holidays to celebrate and plan out your content accordingly.

Best practices for scheduling tweets

If you are ready to start scheduling your tweets, here are a few best practices to follow before you get started:

Use a social media management tool to schedule your tweets in advance
I recommend setting up a free account on HYPEFURRY, where you can start adding in all of the tweets you want to schedule.

Schedule your tweets for the times when your audience is on Twitter
Pay attention to the best time to post on Twitter, but also to when you are getting the most engagement and schedule your tweets to be sent out at those times.

Mix up your tweet content to keep it interesting

Try new things on Twitter, like scheduling your Twitter threads or posting videos if you normally post only text, to see how it all performs with your audience.

Don't rely solely on scheduled tweets

Don’t “post and ghost” by scheduling all of your tweets and then not responding to any of the replies. Make sure that you have time set aside to engage with your followers when they reply to your posts.

Analyze your tweet performance

Make sure you are regularly looking at how your tweets are performing to see what's working and what's not and adjust your content strategy from there.

Scheduling tweets has saved my loads of time, I hope it can do the same for you! ✨

Follow me as well :) @AbhijeetBGavali

A dataset of LinkedIn users and businesses

Abhijeet Gavali — Thu, 13 Oct 2022 03:35:37 +0000

Hello there, developers.
I'd like to tell you about LinkDB, which I recently discovered and found useful. Perhaps you'll find it useful as well.

What exactly is LinkDB?

LinkDB is a comprehensive database of LinkedIn members and businesses from around the world. The information also includes job titles, company names, employees, and executives, and it can be used to identify key business connections. The LinkDB database is updated daily with profiles from LinkedIn and available sources, ensuring that your information is up to date. This database is an excellent resource for businesses looking to expand their networks, find new customers and partners, or simply stay ahead of the competition. Individuals looking to connect with professionals in their field or industry can also use it.

What does it have to offer?

The database contains profiles of over 17 million companies worldwide, as well as profiles of individuals organized by region, industry, and job function. It also contains information on over 5 million industry-specific companies and their executives, such as the company name, location, and website address. When you buy the LinkDB database, you get access to a searchable online portal where you can do more in-depth research on your data. The database includes information on over 5 million industry-specific companies and their executives, such as the company name, location, and website address. When you buy the LinkDB database, you get access to a searchable online portal where you can do more in-depth research on your data. Researchers all over the world use this database for business intelligence purposes such as market segmentation and competitive analysis.

Who was LinkDB originally developed for?

LinkDB is ideal for sales and marketing automation, candidate recruitment, investment analysis, and other applications. It is ideal for you if you are a middle-market company based in the United States or Europe or a startup with at least $1 million in funding.

Finally, the purpose of this post is to inform you about a available LinkedIn Database, so that we can now provide quality developers, sales executives, and other professionals to companies by building a platform around LinkDB and writing some advanced fancy algorithms also termed as "business logic".

The detailed blog can be found here.

I hope you find this useful; please leave feedback in the comments:)

Setting up an expo CLI for development

Abhijeet Gavali — Sat, 07 May 2022 17:20:55 +0000

Hello developers, let’s set up an expo CLI into the machine to start an app-development !

Prerequisites,
You need to have a node install on your machine, haven't? get node from here.
You must have simmulator on your machine. If your mac user you can have Xcode(get from app store) and android both, but this choice is limmited to android for windows user’s, get android studio here.
Let’s check the version of our node and npm, to do so run following command in terminal.

node --version

npm --version

Now we need an expo CLI for initializing our app’s, so we get an expo globally

npm i -g expo-cli

This will install expo CLI on your machine. If your Mac user, you need to prefix this with ‘sudo’ and to install that, you were asked for the password by terminal, go ahead and install expo.

After setting up all, run following command to create a new expo app.

expo init blog-app

This will prompt for choosing template for your project, will go with blank.

Congratulations developers! we have created a new expo app.

We have successfully created our first expo app, now we need to run our app for that you can see this guide.

Till then keep learning :)

DOGECART an ecommerce platform

Abhijeet Gavali — Thu, 13 Jan 2022 07:31:43 +0000

hey guys,
First of all I want to thank dev.to and mongoDB for hosting this amazing hackathon to explore non SQL database as I Wanted to do...

For quick readers

Overview of Submission
Submission Category
Code of the project
Resources, frameworks and code-stack Used in project
Screenshots and Demo video

let's talk about submission as this post is for overview of what I have build, what I have learnt, and the next plan..

Overview of My Submission

It is an online e-commerce platform, I always wanted to create a platform so every one can generate sell from online market, till date no one is providing a platform to explore market for free. yes, there are some but they are not clear about the seller policy they charge before seller makes profit from online market, When I'm exploring the drop shipping I end up with subscription for using platform, so with the help of this hackathon I bound myself to the project for creating a platform, and here is what I come with dogecart

Submission Category

E-Commerce Creation

Code of the project

AbhijeetGavali / dogecart

Repo created for hackthon

About Doge cart

It is an ecomerce platform build to give exprence of online market to seller and provide quality producs to customers from nearby seller

Explore Platform

build it on local for explore

first of all you need to clone the repository and provide the environmental variables get variables from sample.env file and provide values

move to backend folder and configure env file as same

run following command in backend folder to start server

`npm start`

now move to dogecart and run

`npm run dev`

it will start a local development server

happy coding:)

View on GitHub

Additional Resources / Info

Resources, frameworks and code-stack Used in project

In frontend :
- Next Js
- React Js
- Redux
In Backend :
- express
- JWT
- mongoose
- nodemailer
- outlook
In DataBase:
- MongoDB Atlas
- Atlas Search

Screenshots and demo videos

demo video

Home page for searching what you want

Auto couple when you type black

Browsing categories/ subcategories

Product details page

User cart Small

explore more... [feedback is appreciated]

Details of the Project

so long you have gone through what I build, Now allow me to give a quick overview of what I build till now,
First thing first I am a second year engineering student from India, and this project is build by me alone, with some inspiration from YouTube.
Idea behind building this project is to build a platform where sellers can cell their products online in there area as well in hole globe and experience market without any subscription charges, I haven't any experience in web UI design so this is a challenge for me, although I have backend ready for hole project, due to lack of designs I can't come with the actual Idea, so currently users can create acc, verify with their mails, verify orders with mails, most important can search, view and place order, we were providing more product according to the category and subcategory but in future will provide more relevant with the help of AI, all listings your able to see are from my prebuilt store, if you want to know more stay tune in comments ill make hole brief of the model of the platform

at last one thing that I can say is this 30 day's gap span of building the project come with tones of bugs and lots of challenges that I enjoyed the most.

Images used for creating the platform are demo images and used from direct e-commerce platform such as Myntra, flip cart etc

Thanks for reading, if you complete the reading, don't forget to comment!