teleren/devto huggingface dataset:
Forget about SEO: Focus on What Really Matters
Published: 2023-03-05 03:11:00

and stop caring about the money part ( as long as it's not your job obviously ), here is why.

<h1>It adds resistance</h1>

When you are starting with blogging, you most likely want to get views on your blog ( wow ). So you go on google, and YouTube searching how to get lots of views on my blog.

You then get lost in other blogs, where they say you need to do these 27 easy steps to get your first 1000 views or you need to buy our template for optimal blog structure and organization. 

Then there is SEO, where you try to compete with all these other blogs of the same topic to be the first link on google, and don't even get started on google analytics. 

I am not hating on SEO, I use SEO all the time to get more views on my blog, my self, but rather it can be a barrier for lots of people to just get to writing their blog. Sometimes we don't want to make blogs on, the top 10 websites to learn JS on, but rather do some blogs on our small projects and other things that the algorithm doesn't necessarily like the most.

In all, it's sort of pointless if you are pushing off writing to focus so much on SEO.

<h1>You have to plan</h1>

Its the most dreaded part of blogging, planning: 

You have to plan the date, the series, the thumbnail, the tags, the audience you want to hit, the things you want to write, etc.

It's something I know I will never master and something I did for a while on hashnode and dev.to, would not recommend it.

No one should be planning this hard, it just adds more stress and makes it feel like a burden. This can stop people from uploading blogs, and actually improving their skills in online writing.

A rule of thumb I like to say is, that everyone should, first of all, make a higher quantity of blogs that take a shorter time than make higher quality blogs that take months.

This is supposed to be a journey. Yes, you see all of these high-quality blogs, and they are getting it out on consistent bases, but these people are teams and professionals who have been doing it much longer than you. Don't get discouraged you will learn as you continue. 

The whole point of blogging is to write and bring your ideas and knowledge more assessable to people. It's meant to inspire and create. For some like me, it's an outlet to share ideas and projects. Don't get consumed by SEO.
RAHASIA ORANG INDIA JAGO DI BIDANG IT
Tags: india, webdev, programming, career
Published: 2023-03-05 02:27:14


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

Sedikit fun fact nya adalah disana profesi IT adalah jadi Mantu Idaman, ibarat di Brazil adalah pesepakbola dan juga di Indo adalah PNS😅Menurut kamu gimana?

😛Yuk belajar bareng serta diskusi dikolom komentar, serta di save biar ga lupa💬😝

🌱Follow : @appardana
💭Stay Young, Be Innovative and Keep Learning

#Design #UI #HTML #CSS #IT #Mantu #Idaman #Web #Skills #IT #Backend #Frontend #Developer #Roadmap #SelfImprovement #Growth #Aditria #Pardana #AditriaPardana #appardana #iAppTech ⚛️💻


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c90e4idp04wsufgdu055.jpg)
empregabilidade na indústria de tecnologia
Tags: devops, webdev, jobs, devjournal
Published: 2023-03-05 02:25:42

Eai galera, tudo Joia?! Meu nome é Kaio e sou estudante de Engenharia da Unesp. Estou realizando uma pesquisa sobre o impacto da era pós-pandemia na empregabilidade na indústria de tecnologia e na ascensão das inteligências artificiais. Será que vocês poderiam me ajudar respondendo a pesquisa abaixo?
https://forms.gle/b34G9Jx6bvrYwhUs7
A little intro
Published: 2023-03-04 23:50:59

My Friend introduced me to dev.to. I really didn't want to do this cause I'm not an open person, I actually prefer to be very private with stuffs I'm going through and things going on around me. Well he made me realize that writing about stuffs sometimes can help easing off one's nerves and here I am trying it absolutely not knowing what to write.
Well I'm a developer. Sometime last year I got into the world of tech. Started off by learning python which I actually enjoyed learning then I decided to go into web dev. Backend web dev to be specific. I actually picked up a course on Coursera and started learning but unfortunately I became inconsistent and lazy that I ended up abandoning it. I actually completed one of the courses then and even got a certificate of completion. I was really excited that day, it was the first time I ever completed an online course so I got really excited. But I gave up on my dream of being a backend developer all because I was lazy and also because I was scared. I was scared of not being good enough. I had met with other developers and their level of commitment intrigued me. I have never been committed to anything before and I was scared of failing and not getting it right. I think that was why I actually stopped. The fear of the unknown prevented me from chasing my dream.
Well now I have decided to let go of that fear. I'll do what I have to do to succeed, I'll take little steps, challenge myself but also not be too hard, acknowledge every little effort I make and not think about how people perceive me. 
"Hello world" I'm ready.
I Created A Simple Note App With Jetpack Compose
Tags: android, programming, showdev, kotlin
Published: 2023-03-05 02:14:07

## Introduction

Hello! 😎
I created a simple note taking app using Jetpack Compose so I'd thought I'd show it to you, it's still pretty simple so any feedback etc. Is appreciated.

---

## The Main Screen

The main screen when the user loads the app is as follows:

![Main Screen](https://i.ibb.co/Z2YT5dD/main-neko-screen.png)

I called me app "NekoMemo" because I have a cat and I like cats. 😺
But this is the landing page, it contains a list of memo items, what time they were created and the user can edit/delete the items as they wish. The user can also created a new memo via clicking on the + button. I've also been trying out admob so you may also notice the advertisement at the bottom.

As for improvements I would like to enter one line of the memo's contents.

---

## Creating And Editing The Memo

The next page is when the user actually creates and or edits a memo:

![Create Edit Memo](https://i.ibb.co/kHM4YPp/memo-contents.png)

Pretty simple we have a title and a contents section, the same component is used for both creating and editing, once the user is done they can click save to save the contents and they will be redirected to the main page. ☺️

---

## Getting Rid Of The Ads

Finally I also implemented getting rid of the ads:

![Remove Ads](https://i.ibb.co/CnngwjY/remove-ads.png)

Since I'm using an emulator that doesn't have Play Store support the play store is disabled, but the user is able to pay $5 to remove all advertisement 😃
Here I learned about the Google Billing API 🥴 It was harder than I thought lol.

---

## Conclusion

Here I have shown a simple app using Jetpack Compose, pretty simple but I'm new to Jetpack Compose so it was a big feat for me. 😆

I'm also starting to get used to Kotlin. Now I need to learn how to actually upload it to the app store. 👀

If you have any recommendations/improvements please let me know in the comments. As always happy coding. 😎

---

Like me work? I post about a variety of topics, if you would like to see more please like and follow me.
Also I love coffee. 

[![“Buy Me A Coffee”](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/ethand9999)

If you are looking to learn Algorithm Patterns to ace the coding interview I recommend the [following course](https://algolab.so/p/algorithms-and-data-structure-video-course?affcode=1413380_bzrepgch)
Hello World!
Tags: beginners
Published: 2023-03-05 02:13:17

My name is Juan Guzman, and I'm excited to start this blog where I'll be sharing my knowledge and experience in programming. In particular, I'll be focusing on topics such as React, TypeScript, NestJS, and AWS.

As a **software developer** with a couple of years of experience, I've had the opportunity to work on a variety of projects using different technologies. However, these four topics have become my favorites over time, and I'm eager to share what I've learned about them.

**React** is a powerful library for building user interfaces.
**TypeScript** is a type-safe version of JavaScript that can help catch errors before they happen, and I've found it to be an invaluable tool for writing more reliable code.
**NestJS** is a framework for building scalable and maintainable backend applications, and I've been using it on several recent projects.
Finally, **AWS** is a cloud computing platform that offers a wide range of services, and I've been exploring its capabilities to build and deploy applications, usually using services as EC2, ECS or RDS, now I'm taking a look to Lambda
Through this blog, I'll be sharing tips, tricks, and tutorials on how to use these technologies effectively. I'll also be sharing my experiences and lessons learned from working on real-world projects. I hope you'll find something valuable here.

Thanks for reading, and stay tuned for more posts!
The Consequences of Property Injection in Tightly Coupled Systems : A Developer’s Guide
Tags: designpatterns, programming, dotnet, microservices
Published: 2023-03-05 01:49:11

Developers may try to use property injection in a tightly coupled system for several reasons:

1.Ease of use: Property injection can be a simple and straightforward way to pass dependencies between objects, making it a popular choice for developers who are new to dependency injection.

2.Familiarity: Developers who are used to working with tightly coupled systems may find it more natural to use property injection, as it resembles the way dependencies are typically handled in tightly coupled systems.

3.Lack of planning: Developers may not have taken the time to plan out the architecture of the application and may make decisions on the fly that lead to the use of property injection in a tightly coupled system.

```
public class OrderService 
{
    private IOrderRepository _orderRepository;
    public IOrderRepository OrderRepository 
    {
        get { return _orderRepository; }
        set { _orderRepository = value; }
    }

    public void SaveOrder(Order order) 
    {
        // Use the injected repository to save the order
        _orderRepository.Save(order);
    }
}
```

```
class Program
{
    static void Main(string[] args)
    {
        // Create an instance of the repository
        var orderRepository = new OrderRepository();

        // Create an instance of the service and property inject the repository
        var orderService = new OrderService();
        orderService.OrderRepository = orderRepository;

        // Create a new order
        var newOrder = new Order { Id = 1, Customer = "John Doe" };

        // Save the order using the service
        orderService.SaveOrder(newOrder);
    }
}
```
In this example, the `OrderService `class has a property called `OrderRepository `of type `IOrderRepository`. The property setter is used to inject an instance of IOrderRepository into the `OrderService `class. The `SaveOrder `method then uses the injected repository to save the order. This type of injection is simple and easy, but it has some drawbacks.

It’s important to notice that the `OrderService `class is tightly coupled to the `IOrderRepository `interface and any class that implements it, making it difficult to change the implementation of the repository without modifying the `OrderService `class. Additionally, it's also not clear from the constructor of the `OrderService `class that the `IOrderRepository `is a required dependency, and it could lead to the class being used without the dependency being set.

It’s important to note that property injection could cause problems in the long run because it makes the dependencies between objects implicit and hard to reason about, and also does not provide compile-time safety. It’s better to avoid this kind of design and invest time to plan the architecture of the application in a way that separates the concerns and make the application more maintainable and scalable.
Revolutionizing Git Workflow: My Experience with aicommits
Published: 2023-03-05 00:51:30

As a developer, optimizing and improving workflow is always a priority. That's why I'm excited to share my experience with aicommits. 

This open-source tool uses OpenAPI to analyze code changes and generate descriptive commit messages automatically. Installation is straightforward, using `npm install -g aicommits`. After installation, aicommits will create commit messages automatically based on the changes made to your repository.

The awesome feature of aicommits is its ability to understand the context of your code changes and create a contextual commit message. This tool helps save time and improve the quality of your codebase by accurately reflecting changes made, making it easier for your team to review and understand the code.

While aicommits is undoubtedly an excellent tool for developers, it's essential to highlight a potential security issue associated with its usage. Since aicommits reads and analyzes the code context, it could potentially expose sensitive information such as API keys, passwords, and other secrets or the intellectual property itself, in this case, the source code.

While aicommits can be an invaluable tool for developers, it's essential to use it with caution and follow best practices to ensure the security of your codebase. By taking the necessary precautions, you can enjoy the benefits of aicommits while keeping your codebase safe and secure.

In conclusion, aicommits is an excellent tool for optimizing your workflow and codebase quality and git log. Its ease of use, powerful NLP (Natural Language Processing) capabilities, and ability to understand the context of your code changes make it an indispensable tool for any developer. Give aicommits a try and simplify your Git workflow while saving time.


---

#### Thanks

Special thanks to the creators Nutlope and Hiroki Osame, this project its really awesome! 

---

#### References

1. https://github.com/Nutlope/aicommits
2. https://en.wikipedia.org/wiki/Natural_language_processing
3. https://github.com/privatenumber
4. https://github.com/Nutlope
Some common scenarios where using git stash can be useful in a development workflow.
Tags: git, github, beginners
Published: 2023-03-05 00:01:24

Git stash can be a useful tool in certain situations, such as when you need to quickly switch to another branch or work on a different feature. However, it's important to use this feature accordingly and in conjunction with other Git commands and techniques to ensure that your development workflow stays organized and manageable.

I find Git stash particularly useful in situations where I realize that I forgot something in my previous commit, and have already moved on to working on the next one within the same branch.

Here are some commands you can use:

`git stash` (command to save any changes that you haven't committed yet into a "stash". Please note that this command removes those changes from the working tree.)

`git checkout other_branch` (to switch to the desired branch -- in this case 'other_branch')

`git stash list` (check list of stashes)

`git stash apply` (apply the saved changes from stash to the current branch's working tree.)

`git stash apply stash@{12}` (in case you have multiple stashes, you can specify which stash to apply. Here, we are applying the 12th stash.)

`git stash drop stash@{0}` (to remove from stash list -- in this case stash 0)

`git stash pop stash@{1}` (to apply selected stash and drop it from stash list)

PS.
To save `git stash` with custom commented, we simply use 
`git stash push -m "my-stash-name"` and then to apply changes use
`git stash apply stash^{/my-stash-name}`

So basically, Stash command is like a little magic trick for your changes. It lets you keep some changes that you don't need or want right now, but you may need them later on.
Why separating services could let your app fail gradually
Published: 2023-03-09 11:37:13

---
title: Why separating services could let your app fail gradually
published: true
date: 2023-03-05 00:00:00 UTC
tags: 
canonical_url: https://karas.codes/posts/why-separating-services-could-let-your-app-fail-gradually/
---

# Context

Some time ago my team in a company that I work on had really serious issue. I fixed one feature that started working as expected, but it also started sending a lot more notification emails to our clients - nearly 150k / a day.

As you probably guess we ran out of quota. What's worse it happened for all applications we develop.

# How could we prevent it?

My advice probably is not ideal and won't save you in similar case, but it will:

* help you survive longer
* give more time to prepare a fix
* won't crash all applications or modules that are sending emails, fail gradually in other words

# Solution

Solution is very simple. When developing such thing as sending emails that are very important from business perspective. You should divide quota per every application or module that would be using it.

Thanks to that:

* only one app or module would be affected or ran out of quota (the rest would be working as intended)
* it will give you a space to shift quota a little if needed
* it will give you more time to prepare a fix, because not all parts of your app would be affected

# Additional steps

Of course this is not only thing you could do. You could:

* implement sending emails or notifications in bulk as my very smart colleague did :)  
* implement metrics and alerting in order to spot your problem before your app would be crashed

# Summary

So as you see following very simple rule of applications and modules separation on application or infrastructure level let's say gives you one very important thing. Your system is more resilient and your customers won't be affected by bugs so often.
How to publish your own npm package - Typescript
Published: 2023-03-04 23:34:37

## Introduction

NPM (Node Package Manager) is a popular JavaScript package manager. It is one of the largest software registries with over a million packages. It is an excellent way for developers to share reusable code with other developers. This article will explain how to write and publish an NPM package. We will be using [TSDX](https://tsdx.io/#quick-start) to bootstrap our package. [TSDX](https://tsdx.io/#quick-start) is a zero-config CLI that helps you develop, test, and publish modern TypeScript packages with ease.

### Initialize Our Package

```
npx tsdx create <Your project name>
```
select basic and continue

![Tsdx template selection screen](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mndu5soj2d1dw1g192uz.png)

### Let's write our package

```
// src/index.ts

class MyInfo {

  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  myName() {
    return `Hi there my name is ${this.name}`
  }

  myAge() {
    return `I am ${this.age} years old`
  }

  yearOfBirth() {
    return 2023 - this.age
  }

}

export default MyInfo

```
This is a simple package that takes in the name and age when you create a new instance of the class ` MyInfo `, The instance would have the functions in the class (myName, myAge, yearOfBirth).

We can go ahead and publish our package, Let's go ahead and publish locally for testing.

```
//Publish locally

npm link
```

We can now make use of the above created package in our projects locally

```
//Make use of the package locally

npm link <Your project name>
```

```
import MyInfo from 'Your Project name'

const myInfo = new MyInfo('Williams' , 10);

console.log(myInfo.myName()); // output: "Hi there my name is Williams"
console.log(myInfo.myAge()); // output: "I am 10 years old"
console.log(myInfo.yearOfBirth()); // output: 2013

```

## Publish to the NPM Registry

Now that we have our package written and tested locally, we can publish it to the NPM registry for others to use.

First, you'll need to create an account on the NPM website if you don't already have one. Once you've done that, you can log in to your account from the command line using the npm login command. This will prompt you for your NPM username and password.

```
npm login

```

Next, navigate to the root directory of your project and run the npm publish command. This will package up your code and upload it to the NPM registry.

```
npm publish
```

Congratulations! Your package is now published on the NPM registry and is available for others to use. They can install it in their own projects using the npm install <package-name> command.

In this article, we've learned how to write and publish an NPM package using TSDX. We've covered how to create a new project, write some code, and publish the package to the NPM registry. With these tools and techniques, you can share your own reusable code with others.
Combining Design Thinking, Lean Startup, and Agile for Project Success
Tags: agile, productivity, devops, startup
Published: 2023-03-04 23:31:51



## How Uber Utilized These Three Methodologies to Create a Winning Cycle 🏆

Are you torn between choosing the best methodology for your project? Fear not! According to the consultancy firm Gartner, it's possible to combine **Design Thinking**, **Lean Startup**, and **Agile** to create a cohesive project cycle. 💡

---

The first three stages of **Design Thinking** focus on analyzing the user's problem, followed by **Lean Startup** and **Agile** methodologies working together on prototyping.

---

This is precisely what Uber did to solve the problem of finding a taxi quickly. By using **Design Thinking**, they identified the issue and then envisioned an application that could detect nearby drivers. 🚕

---

To test their potential business model, Uber launched a Minimum Viable Product (MVP) called UBERX to assess the market's viability. Then, they delved into **Agile** methods to meet their customers' expectations and continuously develop their business. They did this by alternating short cycles and adding new features like UBER Pool, UBER Van, and ride-sharing. 🚗

---

This concrete example shows the possibility of combining all three methodologies without having to choose one over the other. By combining them, you can have a comprehensive approach that provides a better understanding of your users, reduces risks, and allows for quicker iterations to meet your customers' needs. 🤝

---

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

So, don't get stuck on choosing just one method. Instead, consider combining **Design Thinking**, **Lean Startup**, and **Agile** for a winning project cycle like Uber did. 💪