DEV Community: Kauna Hassan

Understanding Server-Side Rendering (SSR) vs. Client-Side Rendering (CSR)

Kauna Hassan — Fri, 24 Nov 2023 09:42:55 +0000

Web development has evolved significantly over the years, and one of the fundamental choices developers face is between Server-Side Rendering (SSR) and Client-Side Rendering (CSR). These two rendering approaches have distinct characteristics, benefits, and trade-offs that developers should consider based on their project requirements.

Server-Side Rendering (SSR)

What is SSR?
Server-Side Rendering (SSR) involves generating the HTML of a web page on the server side before sending it to the client's browser. This means that when a user requests a page, the server processes the request, fetches the necessary data, and then creates the HTML content to be.

Pros of SSR:

Improved SEO: Search engines can easily crawl and index content since the HTML is readily available.
Performance: Initial load times can be faster compared to CSR, especially for content-heavy pages.
Better for low-powered devices: SSR can be more efficient for devices with limited processing power as it receives pre-rendered HTML.
First-contentful paint: Users see content sooner as they don't have to wait for client-side rendering to complete.

Cons of SSR:

Server load: SSR can lead to increased server load, especially with a high volume of requests.
Limited interactivity: Complex client-side interactions might require additional effort to implement.
Full-page reloads: Any interaction that requires server-side processing may trigger a full page reload.

Client-Side Rendering (CSR)

What is CSR?
Client-Side Rendering (CSR) involves loading a minimal HTML page from the server and then using JavaScript to render the content on the client side.

Pros of CSR:

Interactivity: Enhanced user interactivity and dynamic content manipulation without full-page reloads.
Reduced server load: Initial server load is lighter as it sends minimal HTML content.
Flexibility: Easier integration with modern JavaScript frameworks like React, Vue.js, and Angular.

Cons of CSR:

SEO challenges: Search engines may have difficulties crawling JavaScript-rendered content.
Performance: Slower initial load times, especially for content-heavy pages or slower devices.
Accessibility: Content might not be immediately accessible to users with slow internet connections or disabled JavaScript.

Code Examples:

Let's illustrate the differences with simple code snippets:

SSR Example (Node.js with Express):

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  // Fetch data and render HTML on the server side
  const data = fetchData();
  const html = renderPageWithData(data);
  res.send(html);
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

CSR Example (React):

import React from 'react';
import ReactDOM from 'react-dom';

const App = () => {
  // Fetch data and render content on the client side
  const [data, setData] = React.useState(null);

  React.useEffect(() => {
    fetchData().then((result) => setData(result));
  }, []);

  return (
    <div>
      {data ? (
        <p>{data}</p>
      ) : (
        <p>Loading...</p>
      )}
    </div>
  );
};

ReactDOM.render(<App />, document.getElementById('root'));

Understanding the differences between Server-Side Rendering (SSR) and Client-Side Rendering (CSR) is crucial for making informed decisions when building web applications. Each approach has its strengths and weaknesses, and choosing the right one depends on various factors such as project requirements, performance considerations, and SEO needs.

Getting Started with Routers in Next.js 13

Kauna Hassan — Wed, 15 Nov 2023 08:17:15 +0000

Next.js 13 introduces powerful enhancements to its routing capabilities, allowing developers to build dynamic and seamless web applications with ease. The updated version simplifies routing through its enhanced router, providing more control and flexibility. In this article, we'll explore how to leverage routers in Next.js 13 to create dynamic and efficient web applications.

What's New in Next.js 13?

Next.js 13 brings improvements to its routing system with the introduction of the useRouter hook, making navigation and handling of dynamic routes more intuitive. Let's dive into the steps to utilize this feature effectively:

Setting Up Next.js 13

Firstly, ensure you have Next.js 13 installed. You can create a new Next.js project or update an existing one by using npm or yarn:

# Create a new Next.js project
npx create-next-app@latest my-next-app

# Or update an existing project
npm update next@latest react@latest react-dom@latest
# Or
yarn upgrade next@latest react@latest react-dom@latest

Implementing the Router

Next.js 13 introduces the useRouter hook, providing easy access to the router object. Here's a basic example of how you can use it in your components:

// pages/index.js

import { useRouter } from 'next/router';

function HomePage() {
  const router = useRouter();

  const handleNavigation = () => {
    router.push('/about'); // Navigates to the /about page
  };

  return (
    <div>
      <h1>Welcome to Next.js!</h1>
      <button onClick={handleNavigation}>Go to About Page</button>
    </div>
  );
}

export default HomePage;

Dynamic Routing

Next.js 13 simplifies handling dynamic routes through file-based routing. For dynamic routes, create files inside the pages directory using brackets [] to denote dynamic segments:

// pages/post/[slug].js

import { useRouter } from 'next/router';

function Post() {
  const router = useRouter();
  const { slug } = router.query;

  return (
    <div>
      <h1>Post: {slug}</h1>
      {/* Display the content of the post */}
    </div>
  );
}

export default Post;

Accessing Route Parameters

To access route parameters in your components, use the useRouter hook's query property. It provides access to dynamic route parameters:

// pages/post/[id].js

import { useRouter } from 'next/router';

function Post() {
  const router = useRouter();
  const { id } = router.query;

  // Fetch data based on the post ID

  return (
    <div>
      <h1>Post ID: {id}</h1>
      {/* Display the content of the post */}
    </div>
  );
}

export default Post;

Conclusion

Next.js 13 simplifies routing by introducing the useRouter hook, providing a more efficient and intuitive way to handle navigation and dynamic routes. Utilize these capabilities to create robust and dynamic web applications with ease.

Explore the Next.js documentation for more advanced routing features and customization options. With these enhancements, building complex applications with seamless routing becomes a more straightforward and enjoyable process.

Creating Interactive Web Animations with CSS and JavaScript

Kauna Hassan — Fri, 10 Nov 2023 07:27:47 +0000

In the dynamic world of web development, creating engaging and interactive user experiences is essential. One powerful way to achieve this is through the use of animations. In this article, we'll explore how to create interactive web animations using a combination of CSS and JavaScript.

Getting Started

Before we dive into the code, it's important to understand the basics of web animations. CSS (Cascading Style Sheets) is a powerful tool for styling web pages, and it includes features for animating elements. JavaScript, on the other hand, provides the interactivity needed to make animations respond to user actions.

Let's start with a simple example. Suppose you have an HTML element with the ID "animatedElement" that you want to animate. Here's how you can apply a basic CSS animation:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Interactive Web Animations</title>
  <style>
    #animatedElement {
      width: 100px;
      height: 100px;
      background-color: #3498db;
      animation: bounce 1s infinite alternate;
    }

    @keyframes bounce {
      0% {
        transform: translateY(0);
      }
      100% {
        transform: translateY(20px);
      }
    }
  </style>
</head>
<body>
  <div id="animatedElement"></div>

  <script>
    // JavaScript code for interactivity will go here
  </script>
</body>
</html>

In this example, we define a CSS animation called "bounce" that alters the translateY property of the #animatedElement. The animation runs infinitely and alternates between the initial and final states.

Adding Interactivity with JavaScript

To make our animation interactive, we can use JavaScript to respond to user actions. Let's modify our previous example to make the animation start when the user clicks on the element:

<!-- ... (head and styles remain the same) ... -->

<body>
  <div id="animatedElement" onclick="startAnimation()"></div>

  <script>
    function startAnimation() {
      const element = document.getElementById('animatedElement');
      element.style.animationPlayState = 'running';
    }
  </script>
</body>
</html>

Now, when the user clicks on the #animatedElement, the startAnimation function is called, setting the animationPlayState property to 'running'. This property controls whether the animation is running or paused.

Responding to User Input

Let's take interactivity a step further by responding to user input, such as mouse movements. We can modify the JavaScript code to make the animation follow the cursor:

<!-- ... (head and styles remain the same) ... -->

<body>
  <div id="animatedElement"></div>

  <script>
    const element = document.getElementById('animatedElement');

    document.addEventListener('mousemove', (event) => {
      const x = event.clientX;
      const y = event.clientY;
      element.style.transform = `translate(${x}px, ${y}px)`;
    });
  </script>
</body>
</html>

Now, the #animatedElement will follow the cursor as you move it across the screen.

Conclusion

Combining CSS animations with JavaScript interactivity opens up a world of possibilities for creating engaging web experiences. Whether you're animating elements based on user actions or responding to input, the synergy of CSS and JavaScript provides a powerful toolkit for crafting interactive web animations. Experiment with different properties, timings, and events to bring your web pages to life.

How to GraphQL in Your React.js Project

Kauna Hassan — Fri, 10 Nov 2023 07:04:20 +0000

GraphQL has become a popular choice for building APIs due to its flexibility and efficiency. When combined with React.js, a powerful JavaScript library for building user interfaces, it opens up a world of possibilities for creating dynamic and responsive web applications. In this guide, we'll walk through the basics of integrating GraphQL into your React.js project.

What is GraphQL?

GraphQL is a query language for APIs and a runtime for executing those queries with your existing data. It allows you to request only the data you need, making your API calls more efficient. Unlike traditional REST APIs where the server determines the response structure, GraphQL empowers the client to define the shape and structure of the data it needs.

Setting Up Your React.js Project

Before diving into GraphQL, make sure you have a React.js project set up. If you haven't already, you can create a new React app using:

npx create-react-app my-graphql-app
cd my-graphql-app
npm start

Now, let's install the necessary packages for GraphQL:

npm install graphql @apollo/client

The @apollo/client package is the Apollo Client, a powerful library for managing state and making GraphQL requests in your React app.

Connecting to GraphQL Server

To use GraphQL in your React.js project, you need to connect to a GraphQL server. For this example, let's assume you have a GraphQL server running at http://localhost:4000/graphql. You can replace this URL with your actual GraphQL server endpoint.

Create a file named client.js in your project's src folder and set up the Apollo Client:

// src/client.js
import { ApolloClient, InMemoryCache } from '@apollo/client';

const client = new ApolloClient({
  uri: 'http://localhost:4000/graphql',
  cache: new InMemoryCache(),
});

export default client;

Fetching Data with GraphQL in React Components

Now, let's use GraphQL to fetch data in a React component. Create a new component, for example, PostList.js:

// src/components/PostList.js
import React from 'react';
import { useQuery, gql } from '@apollo/client';

const GET_POSTS = gql`
  query GetPosts {
    posts {
      id
      title
      body
    }
  }
`;

function PostList() {
  const { loading, error, data } = useQuery(GET_POSTS);

  if (loading) return <p>Loading...</p>;
  if (error) return <p>Error: {error.message}</p>;

  return (
    <div>
      <h2>Post List</h2>
      <ul>
        {data.posts.map((post) => (
          <li key={post.id}>
            <strong>{post.title}</strong>: {post.body}
          </li>
        ))}
      </ul>
    </div>
  );
}

export default PostList;

In this example, we use the useQuery hook from @apollo/client to execute the GET_POSTS query. The loading and error states are handled, and the data is displayed once it's available.

Integrating GraphQL into Your App

Finally, integrate the PostList component into your main App.js:

// src/App.js
import React from 'react';
import { ApolloProvider } from '@apollo/client';
import client from './client';
import PostList from './components/PostList';

function App() {
  return (
    <ApolloProvider client={client}>
      <div className="App">
        <h1>GraphQL in React App</h1>
        <PostList />
      </div>
    </ApolloProvider>
  );
}

export default App;

Wrap your app with the ApolloProvider component and pass the client instance as a prop to make GraphQL queries available throughout your app.

And there you have it! You've successfully integrated GraphQL into your React.js project. This is just a starting point, and you can now explore more advanced features such as mutations, subscriptions, and caching with Apollo Client as your application grows.

Using Tailwind CSS with React.js: A Concise Guide

Kauna Hassan — Fri, 10 Nov 2023 06:54:11 +0000

Tailwind CSS is a utility-first CSS framework that enables developers to quickly build modern and responsive user interfaces. When combined with React.js, a popular JavaScript library for building user interfaces, the two technologies synergize to streamline the development process. In this article, we'll explore how to integrate Tailwind CSS seamlessly into a React.js project.

Prerequisites

Before diving into the integration process, make sure you have both Node.js and npm (Node Package Manager) installed on your machine. You can install them by visiting Node.js and following the installation instructions.

Step 1: Create a React App

If you haven't already set up a React app, use the following commands to create one:

npx create-react-app my-tailwind-app
cd my-tailwind-app

Step 2: Install Tailwind CSS

Next, install Tailwind CSS and its dependencies using npm:

npm install tailwindcss postcss autoprefixer

Step 3: Configure Tailwind CSS

Create a tailwind.config.js file in the root of your project and configure it:

// tailwind.config.js
module.exports = {
  content: [
    "./src/**/*.{js,ts,jsx,tsx}",
    "./public/index.html",
  ],
  theme: {},
  plugins: [],
};

Step 4: Create PostCSS Configuration

Create a postcss.config.js file in the project root:

// postcss.config.js
module.exports = {
  plugins: {
    tailwindcss: {},
    autoprefixer: {},
  },
};

Step 5: Import Tailwind CSS in your styles

Open the src/index.css file and import Tailwind CSS:

/* src/index.css */
@import 'tailwindcss/base';
@import 'tailwindcss/components';
@import 'tailwindcss/utilities';

Step 6: Use Tailwind CSS Classes in React Components

Now, you can use Tailwind CSS classes directly in your React components. For example:

// src/components/MyComponent.jsx
import React from 'react';

const MyComponent = () => {
  return (
    <div className="bg-blue-500 text-white p-4">
      This is a Tailwind CSS styled component.
    </div>
  );
};

export default MyComponent;

Step 7: Run your React App

Finally, start your React app to see the integration in action:

npm start

Visit http://localhost:3000 in your browser, and you should see your React app with Tailwind CSS styles applied.

Conclusion

Integrating Tailwind CSS with React.js offers a powerful combination for efficient and responsive web development. By following these steps, you can quickly set up and leverage Tailwind CSS classes in your React components. This approach not only enhances your development speed but also ensures a consistent and visually appealing user interface.

State Management with Redux

Kauna Hassan — Mon, 21 Aug 2023 09:03:06 +0000

Introduction

State management is a crucial aspect of front-end development, especially in larger applications where maintaining a consistent and predictable state becomes challenging. Redux, a popular state management library, provides an elegant solution to this problem. In this article, we'll delve into what Redux is, how it works, and how to implement it in your projects.

Understanding Redux

Redux is a predictable state container for JavaScript applications, primarily used with frameworks like React. It helps manage the state of an application in a centralised and organised manner, making it easier to debug, test, and reason about the application's behaviour.

At the core of Redux, we have three key principles:

Single Source of Truth: Redux stores the entire application state in a single JavaScript object called the store. This centralises the state and simplifies the process of tracking changes.

State is Read-Only: The state within the Redux store cannot be directly modified. Instead, to make changes, you dispatch actions that describe what happened. These actions are plain JavaScript objects containing a type field and optional payload data.

Changes are made by Pure Functions: To specify how the state changes in response to actions, you define pure reducers. Reducers take the current state and an action, and return the new state. This ensures predictability and traceability of state changes.

Setting Up Redux

To get started with Redux, you'll need to install the necessary packages:

npm install redux react-redux

Now, let's dive into the implementation.

Create a Store:

First, you'll need to create a Redux store using the createStore function provided by Redux.

// store.js
import { createStore } from 'redux';
import rootReducer from './reducers';

const store = createStore(rootReducer);

export default store;

Define Reducers:

Reducers define how the state changes in response to actions. Each reducer typically handles a specific portion of the state.

// reducers.js
const initialState = {
  count: 0,
};

const counterReducer = (state = initialState, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return { ...state, count: state.count + 1 };
    case 'DECREMENT':
      return { ...state, count: state.count - 1 };
    default:
      return state;
  }
};

export default counterReducer;

Combine Reducers:

If your application has multiple reducers, you can combine them using the combineReducers function.


// reducers.js
import { combineReducers } from 'redux';
import counterReducer from './counterReducer';

const rootReducer = combineReducers({
  counter: counterReducer,
});

export default rootReducer;

Connect Redux to React:

To connect your React components to the Redux store, you'll use the connect function provided by the react-redux package.

// Counter.js
import React from 'react';
import { connect } from 'react-redux';

const Counter = ({ count, increment, decrement }) => {
  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={increment}>Increment</button>
      <button onClick={decrement}>Decrement</button>
    </div>
  );
};

const mapStateToProps = state => {
  return {
    count: state.counter.count,
  };
};

const mapDispatchToProps = dispatch => {
  return {
    increment: () => dispatch({ type: 'INCREMENT' }),
    decrement: () => dispatch({ type: 'DECREMENT' }),
  };
};

export default connect(mapStateToProps, mapDispatchToProps)(Counter);

Conclusion

Redux is a powerful state management library that promotes a predictable and structured approach to handling state in front-end applications. By following the principles of a single source of truth, read-only state, and pure functions, Redux simplifies the complexity of state management in larger projects.

To explore more about Redux, check out the official Redux documentation. Incorporating Redux into your React applications can significantly enhance maintainability and scalability.

Remember, mastering Redux takes practice, so don't hesitate to experiment and build projects to solidify your understanding.

References:

Redux Official Documentation
React Redux

Building a Slack Bot in Python

Kauna Hassan — Sat, 29 Jul 2023 00:57:28 +0000

Introduction

In this article, we will be building a bot in python using the Slack API. We'll go through setting up the development environment and also getting the slack API bot token.

Tools needed:

This bot as mentioned earlier will be requiring python and the Slack API but in order to make use of this, we will need certain tools which we will be making use of as follows:

Download Python3
pip and virtualenv
A Slack account

Setting Up The Environment

While we are now aware of the tools and software needed to be able to get coding, we will also need to set up our development environment by going to the command line and changing the directory of where to keep the project folder. We will then need to create a virtual environment to set apart our application dependencies from other projects by inputing the following code to our command line.

virtualenv slackbot

We will then need to activate the virtual environment by inputing the code below:

source slackbot/bin/activate

In addition the slackclient API helper library by slack can then send and receive messages from a slack channel. By using the following code below, we will then need to install the slackclient library using the pip command below:

pip3 install slackclient

The next step in the process is to create a Slack App to receive our API token for the bot.You will then need to pick an app name as shown below:

The next step is choosing a workspace if you're already signed into one or create a new workspace as shown:

APIs and Configuration

The whole idea of the slack bot is ensuring that it operates like any other user participating in conversations in DMs, channels and groups. This is called a bot user that can be set up by selecting "bot users" under the "features" section. Below are a couple of steps involved in adding a bot user.

The first step is clicking on the already created workspace
The next step is going to the App home in the navigation section and then clicking on the review scopes to add button.
After clicking on app home, the next thing is to go to the bots page to get a token and get started with configuring the API.

Following the steps above will lead to a page shown below:

As shown above, the next step is generating a token and in the button shown in the bottom right corner of the screen. A usual practice is to export secret tokens as environment variables as shown below with the name SLACK_TOKEN:

export SLACK_TOKEN='your bot user access token here'

We have now authorised the Slack RTM and Web API.

Bot Coding

In your new folder, create a new file named bot.py and input the code below:

import os
import time
import re
from slackclient import SlackClient

Our dependencies have now been imported and we can now get the values associated with the environment variable and then represent the Slack client as shown in the code below:

# represent the Slack client
slack_client = SlackClient(os.environ.get('SLACK_TOKEN'))
# bot's user ID in Slack: value is assigned after the bot starts up
bot_id = None

# constants
RTM_READ_DELAY = 1 # 1 second delay between reading from RTM
EXAMPLE_COMMAND = "do"
MENTION_REGEX = "^<@(|[WU].+?)>(.*)"

The code above, now represents the SlackClient with the SLACK_TOKEN which is then exported as an environment variable. This now communicates that we could use a variable to store our Slack user ID of the bot. We can then explain the constants which have been declared in the code below:

if __name__ == "__main__":
    if slack_client.rtm_connect(with_team_state=False):
        print("Bot connected and running!")
        # Read bot's user ID by calling Web API method `auth.test`
        starterbot_id = slack_client.api_call("auth.test")["user_id"]
        while True:
            command, channel = parse_bot_commands(slack_client.rtm_read())
            if command:
                handle_command(command, channel)
            time.sleep(RTM_READ_DELAY)
    else:
        print("Connection failed. Exception traceback printed above.")

Our Slack client now connects to the Slack RTM API which now calls our Web API method(auth.test) to get the bot's ID.

The bot user now has a user ID for each workspace the Slack App is installed within. Another point to note is that the program now goes to an infinite loop where each time the loop runs the client, it receives any event that arrives from Slack's RTM API. With careful notice, we will see that before the loop ends, the program pauses for a second such as it doesn't loop so fast and not waste our CPU time.

For each event been read the parse_bot_comands() function now ensures the event contains a command for the bot. This will also ensure the command will contain a value while ensuring the handle command() function knows what to do with the command.

We now have the above explained in the code below:

def parse_bot_commands(slack_events):
    """
        Parses a list of events coming from the Slack RTM API to find bot commands.
        If a bot command is found, this function returns a tuple of command and channel.
        If its not found, then this function returns None, None.
    """
    for event in slack_events:
        if event["type"] == "message" and not "subtype" in event:
            user_id, message = parse_direct_mention(event["text"])
            if user_id == bot_id:
                return message, event["channel"]
    return None, None

def parse_direct_mention(message_text):
    """
        Finds a direct mention (a mention that is at the beginning) in message text
        and returns the user ID which was mentioned. If there is no direct mention, returns None
    """
    matches = re.search(MENTION_REGEX, message_text)
    # the first group contains the username, the second group contains the remaining message
    return (matches.group(1), matches.group(2).strip()) if matches else (None, None)

def handle_command(command, channel):
    """
        Executes bot command if the command is known
    """
    # Default response is help text for the user
    default_response = "Not sure what you mean. Try *{}*.".format(EXAMPLE_COMMAND)

    # Finds and executes the given command, filling in response
    response = None
    # This is where you start to implement more commands!
    if command.startswith(EXAMPLE_COMMAND):
        response = "Sure...write some more code then I can do that!"

    # Sends the response back to the channel
    slack_client.api_call(
        "chat.postMessage",
        channel=channel,
        text=response or default_response
    )

The parse_bot_command() function now takes these events and ensure that they are pointed to the Bot. While there are several event types which our bot will come across, we need to find the commands we want using the message events.

Message events generally have sub-types but in the commands we will find, sub-types won't be defined. These function now filters the not-so-great events by checking the properties.

The next step being taken into consideration is wanting to know if the event represents a message but also finding out if the Bot is mentioned.

Our parse_direct_mention() function will then take the task upon itself of figuring out if the text starts with a mention and then compare it to the user ID we stored in the Bot which if being the same, we know is a bot command and then returns the command text in the channel ID.

The parse_direct_mentions() function will take an expression to determine if a user being confirm if a user has been mentioned in the message. Using this, it then gives us back the user ID with the message none if there is no mention.

Our last function handle_command() is where for future reference adds what makes up the slack bot. It carries a known command to make use of by sending a response to Slack by using the chat.postMessage to call back our Web API.

The code below shows an explanation

import os
import time
import re
from slackclient import SlackClient


# instantiate Slack client
slack_client = SlackClient(os.environ.get('SLACK_BOT_TOKEN'))
# slack user ID in Slack: value is assigned after the bot starts up
slack_id = None

# constants
RTM_READ_DELAY = 1 # 1 second delay between reading from RTM
EXAMPLE_COMMAND = "do"
MENTION_REGEX = "^<@(|[WU].+?)>(.*)"

def parse_bot_commands(slack_events):
    """
        Parses a list of events coming from the Slack RTM API to find bot commands.
        If a bot command is found, this function returns a tuple of command and channel.
        If its not found, then this function returns None, None.
    """
    for event in slack_events:
        if event["type"] == "message" and not "subtype" in event:
            user_id, message = parse_direct_mention(event["text"])
            if user_id == starterbot_id:
                return message, event["channel"]
    return None, None

def parse_direct_mention(message_text):
    """
        Finds a direct mention (a mention that is at the beginning) in message text
        and returns the user ID which was mentioned. If there is no direct mention, returns None
    """
    matches = re.search(MENTION_REGEX, message_text)
    # the first group contains the username, the second group contains the remaining message
    return (matches.group(1), matches.group(2).strip()) if matches else (None, None)

def handle_command(command, channel):
    """
        Executes bot command if the command is known
    """
    # Default response is help text for the user
    default_response = "Not sure what you mean. Try *{}*.".format(EXAMPLE_COMMAND)

    # Finds and executes the given command, filling in response
    response = None
    # This is where you start to implement more commands!
    if command.startswith(EXAMPLE_COMMAND):
        response = "Sure...write some more code then I can do that!"

    # Sends the response back to the channel
    slack_client.api_call(
        "chat.postMessage",
        channel=channel,
        text=response or default_response
    )

if __name__ == "__main__":
    if slack_client.rtm_connect(with_team_state=False):
        print("Starter Bot connected and running!")
        # Read bot's user ID by calling Web API method `auth.test`
        starterbot_id = slack_client.api_call("auth.test")["user_id"]
        while True:
            command, channel = parse_bot_commands(slack_client.rtm_read())
            if command:
                handle_command(command, channel)
            time.sleep(RTM_READ_DELAY)
    else:
        print("Connection failed. Exception traceback printed above.")

We can now run the code by using the following code below:

python3 starterbot.py

The next step is creating a channel as shown below:

You can now start giving commands to your bot.

Conclusion

In conclusion, we looked at creating a Slack bot in this article and proper implementation and usage of the Slack API. A common application of this bot could be in the creation of an onboarding bot to your Slack application. It is also important to integrate a database and also play around with other APIs to integrate to Slack.

Writing a Transmission Control Protocol stack in Python

Kauna Hassan — Fri, 14 Jul 2023 06:14:31 +0000

Introduction

I recently just started taking proper class in Networking and while I was deeply fascinated by the concept of networking, I found it a bit difficult understanding TCP(Transmission Control Protocol).

A couple of basic concepts we would be using are:

Opening a network socket that allows us send TCP packets
Sending a HTTP request to google.com using GET
Getting and Reading the reply we get

Also note, correct error handling wasn't taken into place with this.

TCP handshake

The first thing we will need is to make a handshake with google. Here's a way a TCP handshake works:
Assuming we have a two syllable word index which is broken down into IN-DEX.
The user sending a HTTP requesting gets to use: IN
Google who is accepting this request is assigned: INDEX
while me the user gets to be assigned: DEX

In a simple code, this will look like this:

# My local network IP
src_ip = "192.168.0.11"
# Google's IP
dest_ip = "96.127.250.29"
# IP header: this is coming from me, and going to Google
ip_header = IP(dst=dest_ip, src=src_ip)
# Specify a large random port number for myself (59333),
# and port 80 for Google The "S" flag means this is
# a SYN packet
syn = TCP(dport=80, sport=59333, 
          ack=0, flags="S")
# Send the SYN packet to Google
# scapy uses '/' to combine packets with headers
response = srp(ip_header / syn)
# Add the sequence number 
ack = TCP(dport=80, sport=self.src_port, 
          ack=response.seq, flags="A") 
# Reply with the ACK
srp(ip_header / ack)

What are sequence numbers?

The idea of TCP is ensuring that we're able to resend packets in a case where some packets go missing. Sequence numbers is a way to check if we have missed packets. In a case where google sends a 3 packets with a size of 100, 200, and 300 bytes. While also assuming the initial sequence number to be 0. Now, these packets will have numbers of 0, 100, 300 and 600.

A TCP Sequence Number is a 4-byte field in the TCP header that shows the first byte of the outgoing segment. It also keeps track of how much data has been transferred and received. The TCP Sequence Number field is always set.

An example is, the sequence number for a packet is X. The length for this packet is Y. If the packet is transferred to another side efficiently, then the sequence number for the next packet is X+Y.

When we send or resend packets, how does google then know we have a missed packet? Well, for every time a packet is received by google we also need to send an ACK saying we got the packet with the sequence number. If as at when the server notices the packet hasn't been ACKed(An ACK packet is any TCP packet that acknowledges receiving a message or series of packets), it will then resend it. Find out more concepts on TCP

What happens when you have a TCP stack

If you ran the above code, you'll notice there was an error and we got a different packet. In this case what is happening is:

Python prgram: IN
Google: INDEX
Kernel: Didn't ask for this
Python Program: ..

The question then lies in how do we go around the kernel? One way to do this is through ARP spoofing which is to act as though we have a different IP address 192.168.0.129.

The exchange now looks like:

me: sends packets for 192.168.0.129 to the address
router: goes through with it
my Python program: IN (from 192.168.0.129)
google: INDEX
kernel: this isn't my IP address! <ignore>
my Python program: uses ACK

If you notice, this then works and we can now send packets to get our responses without the kernel getting in the way.

How to get a webpage

To prevent google from sending the html for google we need to take into account the following:

Ensuring to put together a packet with a HTTP GET request
Adequately making sure we can listen for a lot of packets now just a single packet.
Fixing bugs with sequence numbers
Closing the connection properly

The Python set-back

If you notice, once everything got working, using wiresharkto look at the packets being sent looks like this:

User/google: <tcp handshake>
User: GET google.com
google: 100 packets
User: 3 ACKs
google: <starts resending packets>
User: a few more ACKs
google: <reset connection>

In the above scenario, google will send packets faster that the python program could handle, sending ACKs. Google server will then assume there were possible network problems causing the user not to ACK the packets.

This will then reset the connection because google will decide there were connection problems. But we do know the connection is fine and the program was adequately responding. It was an issue where the python program was slow to acknowledge the packets.

Conclusion

One of the set-backs we received was how slow the python program. It is also important to properly understand the main concepts associated with TCPs, how they work and how to handle requests as these will help in ensuring you understand in-depth what TCPs entail and how to solve bugs when they are encountered.

How To Use Tailwind In Vite

Kauna Hassan — Thu, 06 Jul 2023 09:55:14 +0000

Introduction

Creating a project can be quite daunting as we know it, now creating a project using a new technology could be one of uttermost difficulty. Technology as we know of now is evolving and it could be quite a task to keep up with these trends.

Vite has been introduced as a technology that helps with the run time and creating a react application using create-react-app. As developers we often make use of css in the design of websites, but as we know it there have been recent developments of css frameworks such as tailwind that help in efficient development.

Installation

To get started with, vite has to be started in the terminal using this code sample:

With npm



npm create vite@latest

With yarn



yarn create vite

With PNPM



pnpm create vite

A user could also decide to use templates using the following code:

npm 6.x



npm create vite@latest my-vue-app --template vue

npm 7+, extra double-dash is needed:



npm create vite@latest my-vue-app -- --template vue

yarn



yarn create vite my-vue-app --template vue

pnpm



pnpm create vite my-vue-app --template vue

Getting Started

To get started with vite, I have also included images that will be helpful in navigating the process in installation as follows:

The image below showcases the first process in using vite which is choosing the project name as follows:

Below we can see the second process, which involves choosing the package name:

We can also see the process of choosing the framework being used as follows:

After selecting a framework, the user will v=be asked to choose a language desired in being used:

Finally, we can then see that our application has been created and we can then carry out the final process of running the application showcased below:

Below is an image showing the folder containing the files created using vite:

Installing and using Tailwind

As earlier mentioned, tailwind is a CSS framework, created to help in a better experience for the users and also for the developer. To install tailwind, the following processes should be carried out:

Install Tailwind CSS

Install tailwindcss and then generate your tailwind.config.js and postcss.config.js files as follows:



npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p

Configuring the template paths

The next step is setting the paths to the template files in your tailwind.config.js file.



/** @type {import('tailwindcss').Config} */
export default {
  content: [
    "./index.html",
    "./src/**/*.{js,ts,jsx,tsx}",
  ],
  theme: {
    extend: {},
  },
  plugins: [],
}

Adding the Tailwind directives to your CSS file

After configuring the path the next step is to add the @tailwind directives for each of Tailwind’s layers to your ./src/index.css file as shown:



@tailwind base;
@tailwind components;
@tailwind utilities;

Starting the build process

Run your build process using npm run dev



npm run dev

Using Tailwind in your project

You can then start using Tailwind’s utility classes to style your content:



export default function App() {

  return (

    <h1 className="text-3xl font-bold underline">

      Hello world!

    </h1>

  )

}

Conclusion

In conclusion, vite and tailwind have have been received by the developer community and it is important to note that there have been numerous complains on stackoverflow about the above not working for specific individuals. And if you notice this, it's important to ensure the tailwind.config.js file is changed to tailwind.config.cjs as shown in the image below.

Happy coding !

Introduction to React.js

Kauna Hassan — Sun, 28 May 2023 23:49:06 +0000

Introduction

React is a popular open source javascript framework that uses components. React was created by a software engineer at Facebook named Jordan Walke.
As react gained popularity over the years, it began to shape the web development space and it gained much more relevance amongst developers.

Setting up the environment

To set up your react environment you will require the following:

An editor with vscode being a popular editor amongst developers.
Secondly, you will need to install node.js

What are components?

Components are the constituents of a React application and can be sub-divided into functional and class components.

Functional Components
A functional component works with properties commonly known as props to accept an input that will render what out user interface(UI) may eventually look like.

Class Components
Components written using ES6 classes in place of functions are called class components. We will now rewrite the functional component using classes.

While we have expanded on both components, the question then lies in how do I then know when to use which component?

With progression in your development journey it will become clearer when you'll need to add logic for event handlers, manage local state and when you'll need to add lifecycle methods. Else, I'll suggest using functional components.

Conclusion

In this article we have looked extensively on what components are and walked through installing our code editor and node.js. In the next article, we will look at using properties(props) and destructuring in react.

Hi

Kauna Hassan — Sun, 28 May 2023 22:51:29 +0000