DEV Community: Dusan Petkovic

🚀Real-Time Debugging with TagLog

Dusan Petkovic — Mon, 23 Dec 2024 08:09:31 +0000

As developers, we’ve all wrestled with logs—digging through endless lines of data to track down bugs or monitor system health. While tools like LogFns simplify logging for developers, I’ve been exploring a different approach to log management with a platform I’m building: TagLog.

TagLog’s idea is simple: Treat logs like Slack channels. Instead of waiting for logs to batch process or digging through files, you can monitor logs live in real time. It’s like having a conversation with your application where updates stream in as they happen.

I’d love to hear from the dev community:

Would a live logging platform be useful in your workflow, or do you prefer the traditional batch-processing approach?
What’s the biggest challenge you’ve faced when working with logs?

Let’s discuss! Feedback from experienced developers is invaluable as I continue shaping this platform. 🙌

What’s the Best Way to Market Your SaaS as a Solo Developer?

Dusan Petkovic — Tue, 29 Oct 2024 11:41:32 +0000

As developers, we often enjoy building products much more than marketing them—but marketing is crucial if you want users to discover and engage with your SaaS. With limited time and resources, how can solo developers make meaningful progress in growing their user base?

Challenges of Limited Time

One of the biggest obstacles for solo developers is balancing development with promotion. I find myself enjoying the coding process far more than the promotional work, but without that extra effort to reach potential users, it’s hard for the product to gain traction.

Does anyone else feel torn between these two tasks? How do you manage your time effectively?

Building Consistency Over Perfection

My approach has been to take things day by day—setting small, manageable goals rather than aiming for a perfect launch. Regular, small interactions in communities where my potential users might hang out (forums, Dev.to, Reddit, etc.) seem more sustainable. By simply staying active and sharing updates, I’m hoping to gather some early users and feedback over time.

Question for others: How do you stay consistent with marketing activities without feeling overwhelmed?

Leveraging Developer Communities

Developer communities are a great place to find users who understand the value of what I’m building. These communities aren’t just potential customers; they’re also incredibly knowledgeable and willing to share feedback, ideas, and support.

For those who have found success in developer communities, do you have any tips? Which communities have you found most valuable?

The Goal: Users and Feedback

For now, my main focus is on gathering feedback rather than immediate revenue. I want users who are willing to try out the product and let me know what works and what doesn’t. Feedback will shape the roadmap and help me prioritize what users need most.

Fellow devs: What are your experiences with user feedback? How has it influenced your product?

Would love to hear how other developers approach marketing their products! What has worked for you, and what are the biggest challenges you’ve faced in getting your product out there?

My Side Project Journey - Building a Developer-Friendly Logging Tool

Dusan Petkovic — Tue, 29 Oct 2024 00:00:00 +0000

As a full-time software engineer, I’ve always dreamed of creating something on my own —an app that could grow and eventually sustain itself. For me, this meant developing a web application that developers could truly benefit from.

The biggest challenge? Figuring out what to build. I constantly have ideas popping into my head, and while I’ve written down many of them, it wasn’t until recently that I found the momentum to dive into one.

The Journey Started Two Years Ago

Actually, it wasn’t that recent. I began working on this project two years ago, only to set it aside after a few months. I’ve recently revived it, though—almost by accident. After nearly losing all the source code due to a phone mishap (and losing my 2-factor authenticator for my GitHub account), I realized it was a project worth picking back up and seeing through.

The Project: TagLog

My idea originally stemmed from an old tool I used back when I was developing in PHP. There was a service called phpconsole that allowed for smooth log integration, letting you send individual logs to a web app where they’d be formatted nicely for debugging. Although phpconsole is no longer around, the concept stuck with me. I thought, “Why not build something similar but make it simpler, accessible, and cross-platform?”

Working at various companies, I’ve seen firsthand how essential a solid logging tool can be, whether for local debugging or resolving production issues. TagLog was born from this need.

What TagLog Offers

The vision for TagLog is to give developers a clean, organized interface for viewing logs from various sources. It’s designed with channels to organize logs by type, and filtering options that make narrowing down and analyzing logs a breeze.

Some core features include:

Integration with JavaScript projects (and more to come)
Cloud-sync for logs
Channels for log organization
Project-based log grouping , so teams can easily share information
Real-time log updates within channels
Push notifications for new log entries
Custom rule-based notifications (via SMS, email, webhook)

There’s also an upcoming Chrome plugin that will sync console.log and console.error directly to TagLog. This, along with planned support for additional languages and frameworks, should make logging and debugging much easier for developers working across different tech stacks.

Get Early Access

I’m eager to release TagLog as soon as possible, and to make sure it’s the best it can be, I’m offering free PRO account access for developers willing to use it for their projects over the next few months (possibly even a year). This means you can test it out, give feedback, and help shape the tool’s evolution.

Interested? Drop a comment, and I’ll get you set up as one of the first users!

Example: Integrating TagLog with React

Here’s a quick example of how you might use TagLog in a React project:

import { useTaglogInit } from "taglog-web-client";

function TestComponent() {
  const { captureInfo } = useTaglogInit({
    accessKey: "{yourAccessKey}",
    defaultChannel: "{yourChannelKey}",
  });

  return (
    <div>
      <Button
        onClick={(e) => {
          captureInfo("Button Click Event", e);
        }}
      >
        Test Action
      </Button>
    </div>
  );
}

The Road Ahead

This journey is just beginning, and I’m excited to see where it leads. I’ll be sharing updates in the coming weeks once the app goes live at taglog.io. Stay tuned!

How do I build a SasS?

Dusan Petkovic — Thu, 10 Oct 2024 18:29:57 +0000

Aside from working full-time as a software engineer, I’ve always been eager to create something of my own with the potential to grow into something sustainable—specifically, a web application.

One of the hardest parts was deciding what to build. I often have ideas pop into my head, many of which I’ve written down, but it wasn’t until recently that I gained real traction with one of them.

Well, maybe not that recently—I actually started this project two years ago but abandoned it after a few months. I’ve since picked it up again after nearly losing all the source code when my phone died, which also led to the loss of my two-factor authenticator and made my original GitHub account inaccessible.

About the App

Now, more about the project. The original inspiration came from an old web application I used back when I was developing with PHP. There was a service called phpconsole that integrated into projects and sent individual log entries to a web app, presenting them in a nicely formatted way for debugging. Although that service has since been retired, the concept stuck with me, and I thought about creating something similar that would be simple to use and compatible with various platforms.

After spending time at different companies and using a wide range of logging tools, I began to appreciate how a well-designed logging tool can make debugging and issue resolution significantly easier, whether locally or in production.

The core idea is to create a streamlined interface that aggregates logs from various sources into channels, with filtering options to help users narrow down and analyze the logs more effectively.

I need feedback

I have plans to add more features and options, but I’m eager to release this as soon as possible to get feedback. As a result, I’ll be offering PRO account access for free to anyone willing to use it for development over the next few months, maybe even a year.

If you’re interested in getting access and being one of the first users, feel free to comment here!

I’ll share updates in the coming weeks once the app goes live. The domain for the app is taglog.io.

Example: Integrating taglog.io with a React Project

import { useTaglogInit } from 'taglog-web-client'

function TestComponent() {
  const { captureInfo } = useTaglogInit({
    accessKey: '{accessKeyHere}',
    defaultChannel: '{testChannelKey}'
  })

  return (
    <div>
      <Button
        onClick={(e) => {
          captureInfo('Button Event Triggered', e)
        }}
      >
        Test Action
      </Button>
    </div>
  )
}

React Integration: taglog-web-client on npm

Concept Features:

Integration with JavaScript projects
Sync logs to the cloud
Add logs to channels
Group channels into projects and share with team members
Live updates in channels (real-time log streaming)
Push notifications for new logs in channels (when subscribed)
Set up rules to trigger notifications (SMS, email, push, webhook)
Upcoming: Chrome plugin to sync console logs and errors
Upcoming: Sync requests from the web app
Upcoming: Support for additional frameworks and languages

Latest version of Yup and Typescript issues that annoy me!

Dusan Petkovic — Sat, 04 Nov 2023 09:06:29 +0000

Hey everyone, I've recently started a project where I am using Yup with Vite and the latest version of React, but I'm facing some issues.

Namely, I've used Yup to generate validation schemas for data received from an endpoint, such as a POST request body. Then, I realized I could infer my entire Entities from the Yup schemas.

So, I wrote code like the following:

export const questionEntitySchema = Yup.object().shape({
  questionText: Yup.string().required(),
  id: Yup.string().required(),
}).required();

export const getQuestionsSchema = Yup.object().shape({
  questions: Yup.array().of(questionEntitySchema).required(),
});

And I expected the type of getQuestionsSchema to be like the following:

// to infer the type with Yup utility
export type TGetQuestions = Yup.InferType<typeof getQuestionsSchema>;

// what I expect as the inferred type for TGetQuestions
type TGetQuestions = {
    questions: {
        questionText: string;
        id: string;
    }[];
}

However, the problem is that I don't get what I expected; everything I get becomes OPTIONAL, which contradicts the required statements in the schema definition.

// example of what is actually inferred 

type TGetQuestions = {
    questions?: {
        questionText?: string;
        id?: string;
    }[];
}

If it worked as described in the official docs, it would be very convenient to declaratively describe the Entities and DTOs with Yup schemas and then accurately infer them. But from my testing, it doesn't seem to work. I'm not sure if it's a TypeScript-specific issue.

it would be nice to have some additional eyes on this. Maybe I'm doing something wrong here.

Thanks!

Being a Developer Coach - What I Learned.

Dusan Petkovic — Mon, 23 Oct 2023 00:00:00 +0000

When this role was entrusted to me, I wasn’t expecting it at all. Previously, I mostly did development work and some mentoring for junior and new employees who were starting at our company.

In essence, it was new territory for me, and I had to find my own way into it and improve my people skills so that I could help the people in my own coaching team.

How It Happened

Initially, we had a restructuring in the company, and new roles were introduced where we had two paths on which we could develop: as engineers and as managers.

In between, we had a new special role that was called a “Coach”. We didn’t get much context at first about what this new role meant, but anyway, I was awarded the Coach role at our all-hands meeting (to my surprise).

It was overwhelming at first to somehow fit in the new obligations to my new coachees, as I was now responsible for their professional and personal development, and also responsible for their performance. Some questions popped up in my mind, imposter syndrome shining through most of them. How do I qualify to help another person with their career when I often don’t know where I am going?

But as with any new skill, I had to dive deep and figure it out, find resources to learn from, and talk to other Coaches to get some insight into how they approached their coaching teams.

The Why

The reason for introducing this kind of managerial role for a company, from my understanding, is to have better visibility into a growing organization, where each employee in the company has a dedicated “Coach” they basically report to, while the Coaches report to the company top management. It’s essentially an Engineering Manager type role, with more focus on helping developers be and achieve their best.

Here Are Some Processes and Methods I Used

✧ 1-on-1 meetings with each team member

One of the first decisions I made to start in this new role was to organize 1-on-1 meetings and get acquainted with each of my team members. Even though some coaches did the first meeting with all their coachees present, that style didn’t really work for my personality. I like to be able to focus on the person to get to know them. I also didn’t yet have a proven way to get things going, so 1-on-1 style better suited my situation as I could be flexible and change my approach based on a team member’s specific needs.

✧ Schedule regular checkups/syncs

After getting to know each person in my team, my second decision was to schedule a monthly meeting/checkup with them. The goal of this was to be able to get a sense of how they are doing on a particular project they are working on and if they have any problems we can discuss.

✧ Have notes

The next important point I realized is that it’s hard to keep track of the discussions and remember the things we talked about and decided on as action items. So ideally, it’s best to have a shared document with each coachee where you outline meeting goals and decisions or action items, so it’s much easier to stay accountable.

✧ Listen first

The whole point of coaching developers is to be able to understand where they are right now so that you can push them forward, and you can only find that out by listening and asking the proper questions.

What lifted you up in the past month, and what weighed you down?
What do you feel is an area where you’re lacking at the moment and would like to improve?
If we had a scale from 1 to 7, where would you put yourself in relation to a skill you would like to develop?
How can I support you?
Do you have any problems in your team? (more specific)
Do you feel like you can raise any concerns to your team or manager? (more specific)

✧ Set goals

It’s hard to move forward and know that you’ve made progress unless you have set goals and ways to measure them. So after a year in my coaching team, I tried to help my coachees set their goals for the next period. Initially, we tried setting the goals for the whole year, but it proved to be hard to fulfill most of the goals because of time constraints. So we trimmed down the goals to be achievable from the coachee’s perspective for the next 6 months.

✧ Be available

In order for coaches to trust me and share their concerns and problems, I think it’s key to just be available. My approach was always to get on a call, and often pair program and have the person describe the problem, where I act as an observer and ask questions. It’s an indispensable tool when doing any kind of mentoring in software development.

✧ Find motivation, switch things up

One of the things that I struggled with, even though my coachees were doing fine on all fronts, is just to find motivation and the why, because you don’t really know how much you’re actually making a difference in the person’s career. We can often get stuck in the regular schedule/agenda, and finding new areas to explore in our sessions is not easy. So my approach there was to ask and get a feel for how we’re doing, and if they feel like they have gotten some real benefit from the discussions. Also, another idea is to just ask the coachee what they would like to talk about.

In the above article, I tried to draw mostly from my own experiences as a manager for a number of developers. You can draw any conclusions from it, but I do hope it’s helpful to anyone starting a similar journey.

👋 If you have any comments or suggestions, feel free to reach out to me!

Hello dev.to World

Dusan Petkovic — Fri, 13 Oct 2023 09:13:19 +0000

Based on my experience with the platform so far, this seems like a great place to spark discussions and exchange ideas.

I've been considering this as a good platform to seek feedback on some of my portfolio projects on GitHub. There are many talented developers here, and I've seen a willingness to comment and offer suggestions.

So here it is—I've developed this React app with a Node.js backend for an interview assignment, which I later modified to use it for my GitHub page. Essentially, it's an employee directory using in-memory storage. I made an effort to apply a domain-driven approach for the front-end part (React), while for the server, it's essentially all in one file (containing all API endpoints).

You can find the project here: Employee List App

I would appreciate anyone who is willing to take a look and suggest how to improve or provide insights on how to make it better.