teleren/devto huggingface dataset:
How do you differentiate Junior/Mid/Senior developer?
Tags: softwareengineer, sharing, thoughts
Published: 2023-07-23 12:03:32

---
title: How do you differentiate Junior/Mid/Senior developer?
published: true
description: 
tags: #softwareengineer #sharing #thoughts
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2023-07-21 00:20 +0000
---


After talking to many experienced Engineers from all ranges varies from 2-14 years of experience and based on response that has 
been received i have compiled the characteristics that is the
major differentiater between 3 roles.


## Questions?

Q1: Do you think having `n` number of years of experince makes you an SENIOR Software engineer?
Q2: Do you think having enough technical knowledge is what makes you an SENIOR Software engineer?
Q3: Do you think becoming a manager and lead what make you SENIOR Software engineer?
Q4: Do you think getting job done and JUST shiping code to production is what makes you SENIOR Software engineer?
Q5: Do you think getting attending meetings with (Stakeholder/PM) what make you SENIOR Software engineer?
Q6: Do you think just delegating your work to juniors make you SENIOR Software engineer?

then IMHO, you can't say that you are SENIOR.

Personally, i believe and even asking from smart engineer almost 80% SE has said the good characteristics
for senior engineer/lead/manager (irrespective of role) is 

- He/She should be good communicator and listener.
- He/She been able to understand business requirements very well and translate those requirements down in the hierarchy to get things done what is required.
- He/She keeps himself up-to date with technical/non-technical knowledge.
- He/She should develop a habit to mentorship, knowledge sharing session with teams. Documenting things should be done and making sure things should be understood by person in his/her team.
- He/She should get knowledge of other domains in case leading teams with people having diverse tech background and level of understanding should be done to such extent that you can able effectively discuss/understand their technical jargons.
- Try to keep meeting short avoid unnecessary meetings because TIME is very important for your team.
- He/She should foster the culture to ask questions in order to bridge the gap between junior/senior (interms of technical debt).
- He/She motivate the team member in their job. Irrespective how small/large work is accomplished. It not only gives respect to his
  member but also build a relationship to do things better way next time. 
- He/She should take ownership with big roles their is big responsibility so utilize it in proper way and showcase your abilities 
  through output.


let me know your thoughts and comments. What do you think what are the characteristics that a make a developer a senior?
Moving and Removing
Tags: perl, python, theweeklychallenge
Published: 2023-07-23 11:47:30

Congratulations to Mohammad for receiving the [White Camel Award](https://whitecamel.org/p/mohammad_sajid_anwar.html) this year. I cannot think of a better recipient for his tireless work within the Perl Community.

## Weekly Challenge 226

Each week Mohammad  S. Anwar sends out [The Weekly Challenge](https://theweeklychallenge.org/), a chance for all of us to come up with solutions to two weekly tasks. My solutions are written in Python first, and then converted to Perl. It's a great way for us all to practice some coding.

[Challenge](https://theweeklychallenge.org/blog/perl-weekly-challenge-226/), [My solutions](https://github.com/manwar/perlweeklychallenge-club/tree/master/challenge-226/sgreen)

## Task 1: Shuffle String

### Task

You are given a string and an array of indices of same length as string.

Write a script to return the string after re-arranging the indices in the correct order.

### My solution

Usually my Perl solution is pretty much a transliteration of my Python solution. This time it isn't. Strings in Python are immutable, which means that cannot be changed like they can in Perl.

#### Python solution

For the Python solution, I create a mapping dict where the key is the integer and the value is the letter.

```python
mapping = {ints[i]: word[i] for i in range(len(ints))}
```

I then sort the key numerically and print the value (letter) in that position

```python
for i in sorted(mapping):
    solution += mapping[i]
```

#### Perl solution

The Perl solution is more straight forward. I work through each pair of letter and position and put the letter in the correct position. In Perl, the [substr](https://perldoc.perl.org/functions/substr) function can be used as both a getter and setter

```perl
foreach my $i ( 0 .. $#ints ) {
    substr( $solution, $ints[$i], 1, substr( $word, $i, 1 ) );
    }
```

### Examples

```bash
$ ./ch-1.py lacelengh 3 2 0 5 4 8 6 7 1
challenge

$ ./ch-1.py rulepark 4 7 3 1 0 5 2 6
perlraku
```

## Task 2: Zero Array

You are given an array of non-negative integers, `@ints`.

Write a script to return the minimum number of operations to make every element equal zero.

In each operation, you are required to pick a positive number less than or equal to the smallest element in the array, then subtract that from each positive element in the array.

### My solution

Unless I am missing something very obvious, the solution is the number of unique positive integers. In Python, we know that a set will remove duplicate numbers, so my solution is as follows:

```python
count = len(set(i for i in ints if i != 0))
```

Meanwhile in Perl, the [uniq](https://metacpan.org/pod/List::Util#uniq) function from List::Util will achieve the same functionality.

```perl
my $count = scalar( uniq grep { $_ != 0 } @ints );
```

### Examples

```bash
$ ./ch-2.py 1 5 0 3 5
3

$ ./ch-2.py 0
0

$ ./ch-2.py 2 1 4 0 3
4
```
Trace Lost or Stolen Mobile devices using Sanchar Saathi Portal
Published: 2023-07-23 11:34:31

Hello friends, here in this article, we are going to share how you can trace you stolen and lost mobile device using [Sanchar Saathi portal](https://sarkari-results.in/sanchar-saathi-portal-sancharsaathi/).

**What is the Sanchar Saathi Portal?**

The Sanchar Saathi portal is an integrated citizen-centric web portal initiated by the Department of Telecommunications. It combines two important modules, TAFCOP and CEIR, to provide comprehensive services to the public. The portal, operated by the Indian government’s Department of Telecommunications, aims to facilitate and assist the general public on a regular basis.
Working Free ChatGPT Plus Accounts
Published: 2023-07-23 11:09:54

Hello, here in this article, we are going to share with you working [Free ChatGPT Plus Accounts](https://www.eonlinetips.com/free-chatgpt-plus-accounts/).

**
ChatGPT premium accounts
**
ChatGPT premium accounts offer a premium subscription service that provides enhanced features and benefits to users. With a premium account, users can access additional functionalities and capabilities beyond the standard free version. Some of the key advantages of ChatGPT premium accounts may include:

Increased Usage Quotas: Premium users often receive higher usage limits, allowing them to interact with the AI model more frequently and for longer sessions.

Priority Access: Premium account holders may have priority access to the latest updates and improvements, ensuring they stay ahead with the most advanced AI capabilities.

Faster Response Times: Premium users might experience faster response times from the AI model, reducing waiting periods and enhancing the user experience.

Specialized Features: Premium accounts may come with exclusive features tailored to specific industries or use cases, providing added value to users in those domains.

Dedicated Support: Subscribers to premium accounts might have access to dedicated customer support to address any issues or inquiries promptly.

Advanced Customization: Premium users could have more options for customizing the AI's behavior, tone, or output to better suit their preferences and needs.

Ad-Free Experience: Some premium subscriptions may offer an ad-free environment, allowing users to focus solely on their interactions with the AI model.
Simple about ASCII
Published: 2023-07-09 15:04:37

### Before We Begin
This blog was inspired by a fantastic explanation of character encoding found on [this](https://www.agiliq.com/blog/2014/11/character-encoding-and-unicode/#ascii) blog.

In my blog, I aim to illustrate the process of encoding in a simple and engaging way.

### Things You Should Know
Computers operate using only 0s and 1s. This means that every character we see on the display needs to be "translated" and stored on the disk as a series of 01010101.

Consequently, the computer needs to find a way to translate the character "A" into 01000001. This challenge was addressed in the past with ASCII.

### ASCII: A Pioneer
ASCII is one of the earliest character encoding schemes.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/h8bzaewg7d4sjf1xh1od.png)

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9azdhtvh0dyhe71bb134.png)

### What is a Character Encoding Scheme?
A character encoding scheme is essentially a table that maps all possible characters to their binary representations. Take a look at the table below for an example.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ms0pxivjjg25xypofow3.png)

To convert "A" to its binary format (01000001), you can locate the intersection of column 0100 and row 0001.

Every computer is equipped with this table, enabling the conversion of English characters to binary format as shown in the example (A => 01000001).

### The Limitations of ASCII
The problem with ASCII is that it was developed in 1963 when computers primarily dealt with English characters. As computers gained popularity and people needed to read and write in other languages, ASCII proved to be insufficient.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tpzw44skty3p9gt93hhk.png)

Due to the inability of ASCII to handle non-English characters, other encoding schemes, such as Unicode, emerged.

Now that you have a better understanding of ASCII, if you'd like an explanation of how the issues with ASCII were resolved, please feel free to leave a comment below. I'd be delighted to share it with you.
Why Zustand Typescript Implementation Is So Ugly
Tags: javascript, react, typescript
Published: 2023-07-23 10:57:44

##### BTW, JavaScript implementation is so clean

### Introduction

Note: This post focuses on Zustand library's implementation in TypeScript. It does not affect the user code, which should be kept clean.

Zustand's JavaScript implementation is very small, as seen in the following tweet.

{% twitter 1583082766081531905 %}

However, its TypeScript implementation is quite complicated. There are several reasons, one of which we explore in this post.

### SetStateInternal type

Let's take a closer look at the `SetStateInternal` type.

(Keep in mind that it's intended for internal use, as we recommend using `StoreApi['setState']` for public APIs.)

https://github.com/pmndrs/zustand/blob/f11cc7f37ad0a53f49370c0e4e659690a1c1a721/src/vanilla.ts#L1-L6

```ts
type SetStateInternal<T> = {
  _(
    partial: T | Partial<T> | { _(state: T): T | Partial<T> }['_'],
    replace?: boolean | undefined
  ): void
}['_']
```

What are those simily characters `['_']`?

It's a TypeScript hack, and the actual character used (in this case, `_`) is not significant; any word would work. We don't go into TypeScript technical details, but let's see what happens if we don't use such a hack.

What we would imagine is the following type as a simpler alternative.

```ts
type SetStateInternal2<T> = (
  partial: T | Partial<T> | ((state: T) => T | Partial<T>),
  replace?: boolean | undefined
) => void
```

This doesn't work for certain cases. Let's explore how it fails with contrived examples.

The first one is the following:

```ts
type State = { name: string; age: number };

declare function run<Fn extends SetStateInternal<unknown>>(fn: Fn): void;
declare function run2<Fn extends SetStateInternal2<unknown>>(fn: Fn): void;
declare const setState: SetStateInternal<State>
declare const setState2: SetStateInternal2<State>
run(setState);
run2(setState2);
```

`run2` causes a type error.

The second one is the following:

```ts
type NameOnlyState = { name: string };
type StoreApi<T> = { setState: SetStateInternal<T> };
type StoreApi2<T> = { setState: SetStateInternal2<T> };
declare const store: StoreApi<State>;
declare const store2: StoreApi2<State>;
const nameOnlyStore: StoreApi<NameOnlyState> = store;
const nameOnlyStore2: StoreApi2<NameOnlyState> = store2;
```

Assigning to `nameOnlyStore2` fails.

You can find the full reproduction in the TypeScript playground: https://tsplay.dev/NBVO4N

As a library consumer, you don't need to know why this happens or how to resolve it. It's something TypeScript magicians should take care of.

### Closing notes

This post has highlighted one of the reasons behind the complexity of Zustand's TypeScript implementation. There are other reasons, which could be addressed in a future post.

---

Originally published at [https://blog.axlight.com](https://blog.axlight.com/posts/why-zustand-typescript-implementation-is-so-ugly/) on July 19, 2023.
Apache AGE: A Deep Dive into Data Import and Export Techniques
Tags: database, datascience, devops, programming
Published: 2023-07-23 10:23:25

Apache AGE is a graph database that provides SQL-based graph modelling capabilities for PostgreSQL. It has opened new avenues in data management, enabling both relational and graph data processing within the same database system. Today, we'll explore data import and export techniques with Apache AGE, ensuring we're equipped to handle our graph data effectively.

## Introduction to AGE

Apache AGE inherits the powerful features of PostgreSQL and integrates the Apache TinkerPop Gremlin graph model and traversal language. AGE extends PostgreSQL's SQL syntax to support graph pattern matching queries, thus enabling relational and graph data processing.

## Data Import in Apache AGE

Let's begin by setting up our environment. Please ensure that you have AGE installed and ready.

### AGE Graph Creation
First, we need to create a graph. We can do so using the following SQL query:
```
SELECT * FROM cypher('CREATE (n:Person {name: $name, age: $age}) RETURN n', 
'{ "name" : "John", "age" : 30 }') AS (n agtype);
```
The above query creates a node labeled `Person` with the properties `name` and `age`.

Importing Data
To import data, we create a `copy from` SQL statement in AGE. The CSV file format is commonly used, so we'll use it as our example. Let's assume we have a CSV file named `persons.csv` with the following data:
```
name,age
John,30
Jane,25
Bob,20
```
We can import this data into our AGE graph as follows:

```
COPY Person(name, age) FROM '/path/to/persons.csv' DELIMITER ',' CSV HEADER;
```

## Data Export in Apache AGE

Exporting data from AGE is also straightforward. We can use the `copy to` SQL command to export the data to a CSV file.
```
COPY (SELECT * FROM Person) TO '/path/to/export.csv' WITH CSV HEADER;
```

This command will export all the data in the `Person` table to a CSV file.

## Conclusion

Apache AGE, with its ability to perform both relational and graph data processing, provides flexibility in data management. This post provided a brief overview of how to import and export data using Apache AGE, which could be the beginning of your journey in handling complex graph data structures with the ease of SQL.

Remember to handle your data carefully and ensure that it is correctly imported and exported to maintain its integrity.

Next time, we'll delve deeper into the graph querying techniques of Apache AGE. Until then, keep exploring and learning!

## References

- [Github](http://github.com/apache/age)
- [Docs](http://age.apache.org)
Simple Planning Poker Online App
Published: 2023-07-23 10:07:15

Hey there,

I wanted to share a project I've been working on called Scrum Jam. It all started because my team and I were struggling to find a simple and user-friendly Planning Poker app. The existing tools either felt too complicated or lacked the features we needed, making the estimation process a bit of a headache.

So, I decided to build Scrum Jam, a free online estimation tool that aims to simplify the whole process. My goal was to create a straightforward and enjoyable experience for all agile teams out there.

Right now, the project is still a work in progress, but I'm genuinely excited about it. I've used Next.js for the frontend and styled it with Tailwind CSS to keep things clean and intuitive. On the backend, I've implemented Node.js websockets hosted on Render.com to ensure smooth real-time communication among team members.

What I enjoy most about this project is focusing on the little details that make a big difference, like micro interactions and an easy-to-use interface. My hope is that Scrum Jam will be a tool that not only helps with estimation but also brings a sense of collaboration and fun to your team's planning sessions.

I would really appreciate your feedback if you decide to give it a try with your team. You can find it at [scrumjam.app](https://www.scrumjam.app/). Let me know what you think, and together, let's make it a valuable resource for the agile community.

Thanks for your support and happy estimating! 🎲🌟
CSS Alchemy: Mastering Tailwind 🎨✨🔧💻
Published: 2023-07-23 10:03:11

🌪️ Tailwind CSS is a utility-first CSS framework meant to let users construct apps more quickly and easily. You may use utility classes to adjust the layout, color, spacing, typography, shadows, and more to build a completely bespoke component design — all without leaving your HTML or writing a single line of custom CSS. 💨🎨✨🔧📝

**For example,** you want to create a simple button.
It's **CSS** Code will looks like :

```
<button class="my-button">
  Save changes
</button>

/* Define the base styles for the button */
.my-button {
  background-color: #4fd1c5;
  color: #fff;
  padding: 0.5rem 1rem;
  border-radius: 0.25rem;
  border: none;
  cursor: pointer;
  transition: background-color 0.2s ease;
}

/* Add hover styles for the button */
.my-button:hover {
  background-color: #38b2ac;
}

```

Ahh, a lot of CSS right!! 😅💻🎨🎉

This same thing is accomplished by using tailwindcss and it looks more precise.

```
<button class="bg-violet-500 hover:bg-violet-600 active:bg-violet-700 focus:outline-none focus:ring focus:ring-violet-300 ...">
  Save changes
</button>
```

As you may expect, the learning curve for Tailwind CSS is mostly comprised of becoming acquainted with its utility classes. But once you've mastered it, you'll be able to construct bespoke components like the one below fast and consistently. 📚💪🚀🎨🧱🔧🔩🧰👨‍💻💡

**How to Use Tailwind CSS to Speed Up Your Coding** 🚀💻💨

Tailwind CSS makes it easier to build and maintain your application's code. You don't have to develop bespoke CSS to style your application if you use this utility-first framework. Instead, you can utilize utility classes to control your application's padding, margin, color, font, shadow, and other properties. 🎨✨🔧📝

It may take some time to become acquainted with these utility classes, but once you do, you'll be able to construct and manage applications faster than ever before. 🏗️🚀🌟

And the most important thing is that one must have a solid knowledge of CSS, otherwise, it would be very difficult to understand it. As under the hood, Tailwind CSS classes have a written block of CSS. 🧠💡📚💻

Having a good understanding of CSS fundamentals will greatly enhance your ability to use Tailwind CSS effectively. While Tailwind abstracts a lot of the complexity by providing utility classes, knowing CSS allows you to have a deeper grasp of how these utilities translate into actual styles. It also empowers you to customize or extend Tailwind CSS when needed, going beyond the pre-defined utility classes. 🛠️🎨🔧

With this combination of CSS knowledge and Tailwind CSS, you'll be equipped to create visually appealing, responsive, and performant web applications efficiently. 🚀💻🎉
My Journey with Next.js
Tags: webdev, typescript, javascript, nextjs
Published: 2023-07-23 10:01:40

**Hello, Dev.to community! Today, I want to share my experience with learning Next.js and how it has transformed my web development skills. As a novice developer, I was intimidated by the idea of server-side rendering and building complex web applications.**

## 1. The Initial Struggle:


![Initial Struggle](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xdt9zbgrn2jd5zhs4zgm.png)

When I first encountered Next.js, I found myself overwhelmed by the amount of new concepts to grasp. Server-side rendering, static site generation, and data fetching with getServerSideProps were just some of the things that left me scratching my head. However, I didn't let this discourage me, and I began my learning journey step by step. 


## 2. The Learning Resources

To start, I relied on the official Next.js documentation and various online tutorials. The Next.js documentation is well-structured and provides clear explanations of its features. I also found numerous blog posts and YouTube tutorials that walked me through building basic applications with Next.js. These resources helped me gain a better understanding of Next.js fundamentals. 

## 3. Hands-on Projects:

While theory is essential, I quickly realized that hands-on projects were crucial to solidifying my knowledge. I started with small projects like personal blogs and portfolio websites. As I progressed, I took on more ambitious projects that leveraged Next.js's powerful capabilities for dynamic content and real-time data updates.

## 4. Learning from Mistakes:

During my journey, I made mistakes - lots of them! However, each mistake taught me something valuable. From debugging errors to refactoring code for better performance, these experiences were invaluable in honing my Next.js skills.

## 5. Levelling up with Advanced concepts:

As I grew more comfortable with Next.js, I explored advanced concepts like API routes, serverless functions, and internationalization. These features opened up new possibilities for my projects, and I felt a sense of accomplishment as I integrated them into my applications.

### Conclusion

If you're new to Next.js or feeling intimidated, remember that every developer starts somewhere. Embrace the learning process, seek support from the community, and don't be afraid to challenge yourself. Happy coding!