sasha

Streamlining Team Collaboration: How Webfuse Spaces Transform Meetings

2024-09-25T10:42:23.652Z

Disclaimer: Meetings are just one of the many use cases for WebFuse. Our web augmentation platform offers much more. However, using WebFuse for standups, interviews, PR reviews, and other routine team activities feels like a perfect match.

Now, let’s dive into our team huddle use case and explore it in detail.

Why Other Meeting Tools Fall Short

1. Information Overload

Team members often struggle to find important links, resources, and documentation scattered across different platforms. This fragmentation leads to wasted time and frustration. Sure, you can pin links in various places, but wouldn’t it be ideal to have them all in one fine-tuned space?

2. Inefficient Collaboration with Original Sources (e.g., Code Reviews)

Code reviews can be cumbersome, involving multiple screens and tools, which makes providing feedback challenging and leads to lengthy back-and-forth communication.

3. Disjointed Communication During Meetings

Traditional video conferencing tools often cause distractions as participants switch between tabs or applications, especially when sharing content. This results in disengagement and miscommunication.

4. Integration Challenges with Extensions

Managing browser extensions individually can lead to inconsistencies and extra steps for team members, limiting access to essential tools.

Why We Love Using WebFuse Spaces

Accessing Web Apps Natively in WebFuse Spaces

One of WebFuse’s standout features is its ability to interact with any website natively in all participants' browsers. This has been a game-changer for our team, especially during code reviews, new ticket assessments, and technical interviews. Imagine discussing a pull request with all team members seeing the same code in real time—without any quality loss. It’s like upgrading from dial-up to high-speed fiber optics!

Configuring Spaces with Apps

In Webfuse, apps are essentially the features you enable within a space, allowing you to tailor it to your team's workflow. For our space, we’ve configured several essential apps to enhance collaboration:

Chat: Enables real-time text communication, perfect for quick messages or sharing links during meetings.
Video Chat: Facilitates face-to-face interactions, as mentioned earlier, with the flexibility to adapt the layout.
Screen Sharing: Allows you to share a native desktop application.
Session Recording: Automatically records all meetings, providing a valuable resource for those who missed the meeting or need to revisit discussions.
File Sharing: Allows team members to upload and share documents or files within the space.

By selectively enabling these apps, we’ve created a versatile environment that caters to our daily standups, reviews, and collaborative sessions.

Enhancing Productivity with Custom Extensions

To streamline our workflow, I developed a couple of browser extensions for GitHub that are now indispensable:

Sprint Points Calculator: This extension calculates sprint points during planning sessions and retrospectives, eliminating the need for mental math.
Pull Request Line Counter: We limit pull requests to 200 lines (excluding documentation and tests). This extension automatically calculates the changed lines in each PR.

The best part? I ported both extensions to WebFuse Spaces without modifications. They function perfectly within the WebFuse environment, providing all team members access to these tools without installing anything in their browsers.

Space Start Page and Bookmarks

WebFuse isolates everything within a single space. Whether it's space settings, apps, extensions, or a custom start page containing all the links we use for daily standups, everything is centralized. No more frantic searches or asking, "Does anyone have the link to the new issues?" Everyone can access essential resources in one place.

We also use a bookmarking feature that allows space members to add their bookmarks directly to the space. This collective curation fosters shared ownership and keeps everyone on the same page—literally. It’s like having a team bookshelf, but more organized!

Video Chat and Recording

WebFuse also integrates video chat, leveraging Vonage with a wrapper that provides multiple configuration options. This flexibility allows us to adapt to different scenarios:

Full-screen mode: Ideal for in-depth discussions, keeping the focus on the topic at hand.
Sidebar layout: Perfect for stand-ups, allowing participants to keep an eye on content like tickets, PRs, or code snippets.

This adaptability is particularly valuable during technical interviews. Candidates often compliment how seamless it is to discuss code in the same tab as the video chat. It transforms what could be a fragmented experience into an engaging conversation.

Another valuable feature of Webfuse's platform is the recording capability. All our team meetings are automatically recorded and stored securely within an s3 bucket. Not only can team members catch up if they miss a meeting, but it also provides a comprehensive record of discussions, decisions, and action items.

Conclusion

WebFuse has become an essential part of our team’s workflow, enhancing collaboration, improving efficiency, and making remote meetings more enjoyable. By adjusting the space to our workflow, integrating key tools like GitHub, and offering a flexible video chat experience, we’ve turned what could be a mundane process into a dynamic, productive environment.

If you’re looking to elevate your team’s meetings from frustrating to innovative, give WebFuse a try.

Light git prompt

2023-12-21T21:05:07.540Z

export GIT_PS1_SHOWDIRTYSTATE=true
export GIT_PS1_SHOWUNTRACKEDFILES=true
export PS1='\[\033[32m\]\u@\h\[\033[00m\]:\[\033[1;36m\]\w\[\033[0;95m\]$(__git_ps1)\[\033[00m\]\$ '

Growing a loop backed ZFS pool

2023-04-13T15:39:46.894Z

LXD doesn’t let you directly grow a loop backed ZFS pool, but you can do so with:

sudo truncate -s +5G /var/snap/lxd/common/lxd/disks/default.img

sudo zpool set autoexpand=on default

sudo zpool online -e lxd /var/snap/lxd/common/lxd/disks/default.img

sudo zpool set autoexpand=off default

Fix Fn key for Keychron K2 in Linux

2023-01-19T21:27:59.720Z

To temporary fix it, try

echo 0 | sudo tee /sys/module/hid_apple/parameters/fnmode

echo 1 | sudo tee /sys/module/hid_apple/parameters/fnmode

To apply changes permanently, do

echo "options hid_apple fnmode=0" | sudo tee -a /etc/modprobe.d/hid_apple.conf ;

Catching a mouse using Raspberry PI

2022-11-27T19:38:58.967Z

Chapter 0: Introduction

To begin with, I live in Amsterdam, The Netherlands. This is a beatiful country with lots of canals, picturesque streets and cozy houses. Cozy houses are also old. Like, really old. The oldest house of Amsterdam, which is located around 100m from my office was built in 1425.

There is one downside though. Mice. There are mice almost in every old house. It's okay if they just live in walls and much worse if they find a way into your appartment. And please forget about mouse traps, the only efficient way to get rid of them is to find the mouse entrance to your appartment and close it. Sometimes it's not easy at all.

This is the moment, where Raspberry PI, Python and Open CV comes to rescue. My idea was to build a piece of software that will detect mice' motion in the kitchen and notify me about it. It should also work in the dark room, cause normally the mouse was coming at night, and I didn't plan to leave the lights on for the whole night. And last, but not least, the process of building the tool should be fun!

Chapter 1: Hardware

I already had a Raspbery PI 3B, which I used for a lot of other fun projects, so I decided to buy a camera and a display (so I can see that little monster). So I went to good old pimoroni.com. Luckily it was Black Friday period, so everything I needed was on nice discounts.

So, here is the list of equipment required to find the mouse:

I will not go into details, about how to connect and install everything, there is lots of info you can find about it on the internet, so here is just a picture of how it looks like. Cute, isn't it?

Raspberry PI + Night vision camera module

Chapter 2: Software

2.0 Requirements

numpy==1.23.5
opencv-python==4.6.0.66
python-telegram-bot==13.14
imageio==2.22.4
python-dotenv==0.21.0
imageio-ffmpeg==0.4.7
huey==2.4.4

2.1: Motion detection

import os
import time
import cv2
import logging
import numpy as np

from dotenv import load_dotenv, dotenv_values
from bg import process_frames

load_dotenv()
CONTOUR_THRESHOLD = int(os.getenv("CONTOUR_THRESHOLD", 20))
WITH_SCREEN = int(os.getenv("WITH_SCREEN", 1))
MIN_GIF_LENGTH = int(os.getenv("MIN_GIF_LENGTH", 30))
GIF_SENDING_THRESHOLD = int(os.getenv("GIF_SENDING_THRESHOLD", 3))
MAX_CONTOURS = int(os.getenv("MAX_CONTOURS", 0))


def run():
    frames_with_motion = []
    previous_frame = None
    cap = cv2.VideoCapture(0)
    last_video_timestamp = None
    
    while True:
        _, frame = cap.read()
        img_rgb = cv2.cvtColor(src=frame, code=cv2.COLOR_BGR2RGB)

        # 2. Prepare image; grayscale and blur
        prepared_frame = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
        prepared_frame = cv2.GaussianBlur(src=prepared_frame, ksize=(5, 5), sigmaX=0)

        # 2. Calculate the difference
        if (previous_frame is None):
            # First frame; there is no previous one yet
            previous_frame = prepared_frame
            continue

        # 3. Set previous frame and continue if there is None
        if (previous_frame is None):
            # First frame; there is no previous one yet
            previous_frame = prepared_frame
            continue

        # calculate difference and update previous frame
        diff_frame = cv2.absdiff(src1=previous_frame, src2=prepared_frame)
        previous_frame = prepared_frame

        # 4. Dilute the image a bit to make differences more seeable; more suitable for contour detection
        kernel = np.ones((6, 6))
        diff_frame = cv2.dilate(diff_frame, kernel, 1)

        # 5. Only take different areas that are different enough (>CONTOUR_THRESHOLD / 255)
        thresh_frame = cv2.threshold(src=diff_frame, thresh=CONTOUR_THRESHOLD, maxval=255, type=cv2.THRESH_BINARY)[1]

        # 6. Find and optionally draw contours
        contours, _ = cv2.findContours(image=thresh_frame, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_SIMPLE)

        # Draw contours
        cv2.drawContours(image=img_rgb, contours=contours, contourIdx=-1, color=(0, 255, 0), thickness=2, lineType=cv2.LINE_AA)

        # If contours detected - save to a video, skip frames with too many contours
        if contours:
            frames_with_motion.append(img_rgb)
        else:
            len_frames = len(frames_with_motion)
            if len_frames > MIN_GIF_LENGTH:
                current_timestamp = int(time.time())

                # We don't want to send the gifs too often
                if last_video_timestamp:
                    if current_timestamp - last_video_timestamp < GIF_SENDING_THRESHOLD:
                        logging.info("Skipping, too soon")
                        continue  # skip, last video too soon
                else:
                    last_video_timestamp = current_timestamp
                
                # Process in background
                process_frames(frames_with_motion, f'{current_timestamp}.mp4')

            frames_with_motion = []

        if WITH_SCREEN:
            cv2.imshow('Motion detector', img_rgb)

        if (cv2.waitKey(30) == 27):
            break

    # Cleanup
    cv2.destroyAllWindows()    


if __name__ == "__main__":
    config = dotenv_values()
    logging.info(f"Starting Jerry with threshold setting {config}")
    run()

2.2: Notifications

import telegram
import os
import imageio
import logging

from huey import SqliteHuey
from dotenv import load_dotenv, dotenv_values

load_dotenv()
TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
config = dotenv_values()
logging.info(f"Starting Jerry with threshold setting {config}")

huey = SqliteHuey(filename='q.db')


@huey.task()
def send_gif(file_name, text):
    try:
        bot = telegram.Bot(token=TELEGRAM_BOT_TOKEN)
        bot.send_video(
            chat_id=TELEGRAM_CHAT_ID,
            video=open(file_name, 'rb'),
            caption=text,
            supports_streaming=True
        )
    except Exception as e:
        logging.error(f"Erorr when sending video: {e}")
    
    try:
        os.remove(file_name)
    except Exception as e:
        logging.error(f"Erorr when deleting video: {e}")


@huey.task()
def process_frames(frames, filename):
    try:
        imageio.mimsave(filename, frames, fps=24)
    except Exception as e:
        logging.error(f"Error when saving video: {e}")
    else:
        send_gif(filename, str(len(frames)))

2.3 Process management

I used systemd to manage processes on my raspberry pi, but there are other options as well too (eg cron, bashrc, etc). Here is the config I have in

[Unit]
Description=Jerry the Mouse
After=multi-user.target

[Service]
Type=idle
ExecStart=/home/pi/jerry/venv/bin/python main.py
WorkingDirectory=/home/pi/jerry
Restart=always

[Install]
WantedBy=multi-user.target

...and for the notifications part:

[Unit]
Description=Jerry the Mouse (Background)
After=multi-user.target

[Service]
Type=idle
ExecStart=/home/pi/jerry/venv/bin/huey_consumer bg.huey
WorkingDirectory=/home/pi/jerry
Restart=always

[Install]
WantedBy=multi-user.target

Chapter 3: Results

(Un)fortunately, while I was writing this app, the mouse stopped coming. Probably, I just fixed the holes in the kitchen cabinet, through which it might come. However, to test it I attached a thread to a small bicycle light and pulled the string. The result is exactly what I expected at the beginning!

Not a real mouse, just a box with a thread attached pulled by me :)

Check files used/opened by a process

2022-11-14T13:40:00.992Z

Useful for debugging:

$ ps aux | grep $PROCESS_NAME $ ls -l /proc/$PID/fd $ sudo lsof -i -a -p $PID

redis-cli monitor specific key change

2022-11-07T10:46:51.284Z

Monitoring specific keys in redis:

redis-cli monitor | grep --line-buffered -iE "YOUR_KEY" >> redis-cli.log

Increasing the inotify watch limit

2022-02-28T13:13:40.061Z

Linux uses the inotify package to observe filesystem events, individual files or directories. Increasing the inotify watch limit should hide the warning messages.

# insert the new value into the system config
echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p

# check that the new value was applied
cat /proc/sys/fs/inotify/max_user_watches

# config variable name (not runnable)
fs.inotify.max_user_watches=524288

Reassign keys in Linux

2022-02-23T15:15:15.866Z

Get the key code:

xev | grep keycode

Press the needed key, then copy needed keycode.

In my case I want to reassign key with code 94 to Left shift:

Test it: xmodmap -e "keycode 94 = Shift_L"

Save it:

xmodmap -pke >~/.Xmodmap
echo "xmodmap .Xmodmap" > ~/.xinitrc

Voila!

Swap command and alt on Apple magic keyboard

2022-02-08T20:53:24.022Z

To swap command and alt buttons on Apple Magic Keyboard (and not globally) add the following line in /etc/modprobe.d/hid_apple.conf:

options hid_apple swap_opt_cmd=1