teleren/devto huggingface dataset:
🔔Daily Automated Email Updates: Track Your GitHub Followers Effortlessly!
Tags: github, githubactions, python, automation
Published: 2024-03-04 15:48:37

🌱 My journey on GitHub started as a platform for both development and academic purposes. I've been active on the platform for quite some time now.  Increasing my GitHub followers has been a personal goal, as their engagement matters to me. However, once I noticed a gap: there was no system to track daily follower fluctuations or receive notifications about them.

So, I created a project which gives a simple yet powerful solution to streamline your GitHub follower tracking! With this automation, you'll receive 🔔 daily updates on your follower count straight to your personal email.

I've also included documentation on how to use this project for your own GitHub account, ensuring you stay informed about follower updates. Additionally, a video demonstration has been provided for better understanding. You can also contribute to project for more feature addition.

**⚙️ Technology Used:** Python and GitHub Workplace
**📚 GitHub Repository Link:** [➡️ Click Here](https://github.com/Sumonta056/GitHub-Follower-Notification-Action-Bot) 
**🎥 YouTube Tutorial Link:** [➡️ Click Here](https://youtu.be/yg-PUbzCRHM) 
**🔗 Documentation Link:** [➡️ Click Here](https://github.com/Sumonta056/GitHub-Follower-Notification-Action-Bot/blob/main/README.md)

<div align = "center">

<hr>

### 🤖 GitHub Follower Notification Action-Bot 🤖

**📚 Keep track of GitHub followers with automated notification bot**

Introducing the GitHub Follower Notification Action-Bot, your faithful companion in keeping track of your GitHub followers effortlessly. This innovative project brings the power of automation to your GitHub experience, ensuring you never miss a beat when it comes to engaging with your followers.

##### ✍️ **How it Looks : Feature - 1 (Daily Emails)**

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

##### ✍️ **How it Looks : Feature - 2 (New Follower Special Email)**

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

##### ✍️ **How it Looks : Feature - 3 (When Somebody Unfollows Special Email)**

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


#### 🔃 More Features Coming Soon

- Followers Information (Who Follows or Unfollows) 🔜
- More Information (If anyone start your repository) 🔜
- Quick Emails When Someone Follows You 🔜


</div>

<hr>

## 🌱 How to configure for the project for your profile and email (Follow the Tutorial to Setup you own bot)

- **🎥 YouTube Tutorial Link:** [➡️ Click Here](https://youtu.be/yg-PUbzCRHM) 

<hr>

## 📚 How to Contribute :

Read The Guidelines :  <a href="https://github.com/Sumonta056/GitHub-Follower-Notification-Action-Bot/blob/main/Contribution.md">Here</a>

<hr>

<div align="center">
<strong>&copy; 2024 All Rights Reserved by Sumonta Saha Mridul</strong>
</div>
Improving productivity in coding and development workflows....!!!
Tags: productivity, discuss, aws, career
Published: 2024-03-04 15:47:03

 **Improving productivity** in coding and development workflows is crucial for efficiency and effectiveness. Here are some tips to help you boost your productivity:
 
**1. Use Version Control**
- Git is widely used and can greatly improve collaboration and project management. Learn to use branches, commits, and merges effectively.

**2. Automated Testing**
- Implement unit tests, integration tests, and end-to-end tests to catch bugs early and ensure code reliability.
  
**3. IDE/Editor Shortcuts**
- Learn keyboard shortcuts for your IDE or code editor. This can save a significant amount of time when navigating, editing, and debugging code.

**4. Code Snippets and Templates**
- Create and use code snippets or templates for commonly used code blocks, functions, or project structures.

**5. Utilize Task Lists**
- Break down tasks into smaller, manageable chunks. Tools like Trello, Asana, or GitHub Issues can help organize and track progress.

**6. Continuous Integration/Continuous Deployment (CI/CD)**
- Automate the build, test, and deployment processes to ensure a smooth and quick delivery pipeline.

**7. Pomodoro Technique**
- Work in focused intervals, such as 25 minutes of work followed by a 5-minute break. This helps maintain focus and prevent burnout.

**8. Learn Regular Expressions**
- Regular expressions (regex) can be powerful for searching, replacing, and manipulating text within your code or files.

**9. Code Reviews**
- Participate in and conduct regular code reviews. They improve code quality, catch bugs early, and help share knowledge among team members.

**10. Continuous Learning**
- Stay updated with new technologies, libraries, and best practices. Dedicate time for learning through courses, tutorials, or reading relevant blogs.

**11. Use Productivity Tools**
- Tools like Jira, Slack, Notion, or project management plugins can streamline communication and task management within teams.

**12. Reduce Distractions**
- Find a quiet workspace, use noise-canceling headphones, or employ productivity apps that block distracting websites.

 **13. Document Everything**
- Maintain clear and updated documentation for your projects, APIs, and processes. This saves time for both you and others working on the project.

 **14. Regular Breaks and Exercise**
- Take breaks to refresh your mind and prevent burnout. Physical exercise can also boost productivity and creativity.

 **15. Focus on One Task at a Time**
- Multitasking can lead to decreased productivity and errors. Instead, focus on completing one task before moving on to the next.

   mplementing even a few of these tips can make a significant difference in your coding productivity and overall development workflow. Tailor them to fit your specific needs and working style.
Never Think You Will Always Success
Tags: discuss, learning, career
Published: 2024-03-04 15:35:27

Please don't judge from the title. I have the reasons why.

I always expect to be successful, but I have a plan if I fail. For example, in January, I took the AWS DevOps Professional certification. I set the expectation that I would succeed because I was well prepared. However, I also set the expectation that I might fail and set the plan for how to handle that. Fortunately, I passed the exam. On the other hand, I was not well prepared for AWS Solutions Architect Professional. I had set the expectation that I would fail. Unfortunately, my expectation was right even though the score was more than my goal.

I never think I should be successful. I always set another expectation or another plan if I will fail.

What do you think? If you have another opinion, feel free to comment here. I want to hear some advice from you.
MWC 2024 Barcelona
Published: 2024-03-04 15:30:59

Thank you so much to all the companies and individuals that took interest in our work and shared #insights and #contacts last week at #MWC in #Barcelona. 

Let's continue with this endless path!

#thankyou #thankful #business #businessboost #telco #telcoindustry 
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6pmbuw4wvnul8mktjlo3.jpg)
Excited to Announce ServBay v1.2.3 is Out Now
Tags: php, beginners, webdev, programming
Published: 2024-03-04 15:27:54

Hey, friends,

We are excited to announce that the latest version of ServBay, 1.2.3, is now available! This update includes significant architectural upgrades, bug fixes, and feature enhancements aimed at providing a more stable and efficient user experience. Here are the details of this update


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



## New Features and Improvements

**New architecture and software packages**: We have introduced a new architecture and software packages, especially adding support for ARM64 architecture, enabling native support for Apple silicon chips (M1/M2/M3) and offering a smoother experience for users of these chips.

**Enhanced error logging**: To better diagnose and solve problems, we have added an error log feature in PHP to make error information clearer and easier to track.

**PhpMyAdmin supports MariaDB 11.3**: phpMyAdmin now supports MariaDB version 11.3 to meet user needs for database management. A new default option has been added, pointing to the currently running MariaDB, eliminating the need for users to manually select the MariaDB version.

## Fixes

**App icon size issue**: Fixed an issue where the app icon was displayed incorrectly in some cases. Icons will now maintain the correct size and proportion in all situations.

**PHP 7.0 display issue**: Fixed the issue where PHP 7.0 version was not displayed in the list, ensuring all supported PHP versions are correctly listed and managed in the interface.

**Judgment of ServBay Helper's running condition**: Added a judgment for the running condition of ServBay Helper to ensure ServBay runs correctly.


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



We are always committed to continuously improving product quality and user experience. Thank you for your support for ServBay. We hope you enjoy an even more optimized and smooth experience in version 1.2.3 of ServBay!
Ispconfig3 jailkit DokuWiki nginx directives
Tags: ispconfig, jailkit, dokuwiki, nginx
Published: 2024-03-04 15:13:04

This directives can be saved in ispconfig3 admin panel and used for domains with DokuWiki.
```nginx
    #Support for X-Accel-Redirect
    location ~ ^/data/ { internal ; }
 
    location ~ ^/lib.*\.(js|css|gif|png|ico|jpg|jpeg)$ {
        expires 365d;
    }
 
    location / { try_files $uri $uri/ @dokuwiki; }
 
    location @dokuwiki {
        # rewrites "doku.php/" out of the URLs if you set the userwrite setting to .htaccess in dokuwiki config page
        rewrite ^/_media/(.*) /lib/exe/fetch.php?media=$1 last;
        rewrite ^/_detail/(.*) /lib/exe/detail.php?media=$1 last;
        rewrite ^/_export/([^/]+)/(.*) /doku.php?do=export_$1&id=$2 last;
        rewrite ^/(.*) /doku.php?id=$1&$args last;
    }
```
Ispconfig3 jailkit laravel api nginx directives
Tags: ispconfig, laravel, jailkit, nginx
Published: 2024-03-04 15:09:37

Ispconfig limits user webspace to public `/web` folder and `/private` folder. Since Laravel needs to use parent of public folder directory it is necessary to put all project files to `/web` including `public` folder. Here are working directives for nginx that allows to run laravel api project using ispconfig3 nginx directives that can be saved in admin panel and used for domain configuration. It redirects all public queries to `/web/public` folder.

```nginx
location / {
   if (!uri) { rewrite ^ /public/index.php; }
   try_files /public/$uri /public/$uri/ @rewrite;
}

location @rewrite {
    rewrite ^/(.*)$ /public_html/index.php?$query_string;
}

    location = /public_html/favicon.ico { access_log off; log_not_found off; }
    location = /public_html/robots.txt  { access_log off; log_not_found off; }

    location ~ /\.(?!well-known).* {
        deny all;
    }

error_page 404 /public_html/index.php;
```
Bundling using the Beast
Tags: webdev, javascript, beginners, react
Published: 2024-03-04 15:08:33

In **modern web development**, efficient bundling and optimization tools are essential for streamlining the development process and ensuring optimal performance of web applications. One such tool that has gained popularity is **Parcel** bundler. In this blog post, we will explore the capabilities of **Parcel** bundler and how it enhances the development workflow, along with best practices for its usage.

Visit the complete reading from the below link:
[Read it on Medium](https://medium.com/@ksknew76/bundling-using-the-beast-2878fa59bed1)
Falsey values and -1 returns
Tags: javascript, leetcode
Published: 2024-03-04 14:59:10

This has happened to me a lot, so I thought it was worth reflecting on. I came across a Leetcode problem this morning that asks you to create a method for an array that returns the last item in the array. If the array is empty, return `-1`.

It’s a beginner-level problem, but the gotcha comes in considering falsey values like `null` or `undefined`.

## Intuition

The intuition in solving this problem is to simply get the index of the last item using `.length-1`. If the item exists, return the item. Otherwise, return `-1`. 

This approach has one problem though which is that if the array contains falsey values like `null` or `undefined`, it will return `-1`. 

## Don’t return -1 explicitly

These Leetcode problems arise pretty regularly where you need to return something in an array, otherwise you return `-1`.

There’s a strong intuition, at least for me, to check for some case and then explicitly return `-1` if that case isn’t met. You’ll fail your tests and then see that since the last item you were trying to access is `null`, `-1` was returned instead of `null`. Then you’ll add a check for `null` or `undefined`, but you’ll find that empty arrays also return `undefined`.

A sign that you are approaching the problem incorrectly is acting on this intuition to return `-1` explicitly.

## Derive -1 naturally

If an array is empty, calculating the index with `.length-1` will return `-1`. So to solve the problem eloquently, all you need to do is check for an empty array. If the array is empty, return the index, otherwise return the item.

The code would look something like this.

```
Array.prototype.last = function() {
    const i = this.length-1

    if (i < 0) {
        return i
    }

    return this[i]
}
```

## The lesson

So again, if you don’t want to deal with the headache of failed Leetcode tests on simple af problems, which leave you feeling like more of an imposter than you already are (I'm projecting, you're probably great), make sure to consider falsey values and also be wary of explicit `-1` returns.
Advantages of Modularity: Simplified Development Process
Tags: softwareengineering, modularity, principles, softwaredesign
Published: 2024-03-04 15:06:07

![Adopting modularity in software development
](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gqtrykoo5ha1mpk0q6ka.png)

The adoption of modularity significantly regularized the development process, breaking down a complex software system into **discrete**, **manageable modules**, each encapsulating a specific piece of functionality, and consequently the development workflow became more organized and focused. This type of segmentation helps individual developers or teams to concentrate on their assigned modules, potentially ignoring the entire system's intricacies, increasing efficiency and productivity.

In terms of collaborative and parallel development effort, since modules can be **developed independently**, multiple teams can work **simultaneously** on different parts of the system, with a drastic reduction of the time required for development, which is particularly beneficial in large projects with tight deadlines, as it permits the concurrent progress of various system components.

The modular approach also supports a division of expertise within the development team. Developers can indeed leverage their specific skills and knowledge with the focus on modules that align with their areas of expertise, whether it be user interface design, database management, or business logic implementation. It’s a specialization that amazingly improves the quality of the software, and that contributes to a more satisfying and productive work environment for engineers, as they can engage in work that matches their strengths and, of course, interests.

> Read the full **[Release #8: Principles of Modularity in Software Engineering](https://academy.bytesandhumans.com/p/release-8-principles-of-modularity)** from my newsletter **[Bytes & Humans Academy](https://academy.bytesandhumans.com/)**
Dicas de design para melhorar suas aplicações frontend
Tags: pattern, ux, iuricode
Published: 2024-03-04 15:05:01

## Hierarquia

A hierarquia ajuda na definição do grau de importância. Quando um elemento de design possui várias informações, é importante dar mais peso para o que é mais importante.

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

## Proximidade

Neste princípio temos a base de que informações similares devem estar próximas, ou seja, manter o conteúdo principal próximo das informações secundárias. Fica claro que esses itens pertencem a um grupo e não a outro mais distante.

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

## Alinhamento

Ao inserir informações em um layout precisamos ter em mente que mantê-las organizadas é fundamental para a compreensão do usuário, e o alinhamento ajuda muito nisso.

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

## Cores

Um dos princípios mais importantes é o tom da cor. Ela também é responsável por transmitir emoções, simbolismos e identificar elementos. A paleta de cores precisa ser cuidadosamente escolhida, para transmitir a ideia da marca, sua atmosfera e atrair o público.

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

## Repetição

O princípio da repetição visa fortalecer o padrão visual, ou seja, o alinhamento, o contraste e a proximidade devem ser iguais nas artes seguintes. Assim você seguirá mantendo a consistência da marca.

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

## Contraste

O contraste é o responsável por dar relevância visual ao que deve ser atrativo. Um exemplo é você colocar uma imagem com letras em branco por cima, se na imagem tiver cores claras não teremos contraste, ou seja, não há uma diferenciação de cores.

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

## Espaçamento

Deixar espaços em branco é tão importante quanto todo o resto. Uma determinada quantidade de texto, por exemplo, precisa de espaço para respirar, para que o leitor não se canse ao lê-lo.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ioy8tw5yxzw40tmtuiz0.png)
Como estruturar os elementos de uma aplicação com os padrões F e Z
Tags: pattern, ux, iuricode
Published: 2024-03-04 15:04:57

Existem dois formatos que podemos utilizar quando estruturamos os elementos de uma aplicação. Os formatos que iremos abordar são baseados nos movimentos dos nossos olhos e podem ser aplicados dentro do contexto da cultura ocidental (leitura da esquerda para direita). Essas diretrizes acabam por definir quais são os pontos mais nobres de um conteúdo, ou seja, aqueles que devem conter as informações mais importantes.

## Padrões “F”

Os padrões “F” se aplicam a páginas tradicionais com muitos textos, como artigos ou postagens em blogs.

Um leitor escaneia o lado esquerdo da página, procurando por palavras-chave interessantes em cabeçalhos alinhados à esquerda ou frases de tópicos iniciais, depois para em um ponto e segue lendo em linha à direita, parando quando encontra algo interessante.

O resultado se parece com um “F” (ou “E,” ou algo com ainda mais barras horizontais; mas o termo “F” pegou).

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

Como você pode utilizar isso? Use negrito, itálico, cores ou sublinhado com moderação para destacar informações cruciais. Isso ajuda a guiar os olhos dos leitores para os pontos-chave.

## Padrões “Z”

Os padrões “Z” se aplicam a outros tipos de páginas, como anúncios ou sites, em que as informações não são necessariamente apresentadas em parágrafos em bloco.

O olho de um leitor primeiro escaneia a parte superior da página, onde é possível encontrar informações importantes, depois dispara para o canto oposto na diagonal e faz a mesma coisa na parte inferior da página.

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

Por isso é quase um padrão universal que os sites sigam esse comportamento, colocando as informações mais importantes nos cantos e orientando outras informações importantes nas barras superior e inferior.

## Conclusão

É importante entender como os seus usuários fazem a leitura das informações antes de adotar um padrão. Considere também uma mistura dos padrões mencionados no artigo para chegar a uma solução ideal. Uma boa hierarquia visual irá diminuir o processo cognitivo dos usuários e destacar os pontos mais importantes para que concluam suas tarefas de uma forma mais eficaz.
Design Pattern: Facade
Tags: go, programming, codinginterviews, designpatterns
Published: 2024-03-07 09:24:10

---
title: Design Pattern: Facade
published: true
date: 2024-03-04 15:03:46 UTC
tags: go,programming,codinginterviews,designpatterns
canonical_url: 
---

The “Facade” concept focuses on decomposing a complex system into manageable sub-systems, each having its dedicated representative object also called “Facade”.

![A colorful painting of a collage of 3 images, first is a bottle of mango juice, second is an image of mango farm, third is an image of mango farmers, in the style of 1800s, pixel art](https://cdn-images-1.medium.com/max/1024/1*u-BDFKcbm7ucqs20AjS95g.jpeg)

The pattern bears a resemblance to micro-service models often employed in large-scale web backend systems, where each micro-service's API serves as a representative.

Another usage is to let Facade plays the role of an interface with multiple implementations, symbolizing various sub-systems.

### When to Use

1. **Simplifying Complexity:** create a straightforward interface, making it easier for external entities to interact with complex underlying code. The Facade should be designed to be versatile enough for most common requirements. However, direct access to the code behind the Facade is still possible in rare cases where it is truly necessary.
2. **Managing Dependent Types:** When various types are intricately dependent, rearranging them to go through the Facade can streamline dependencies. Instead of relying on N types, one can depend solely on the Facade.

### Implementation

#### Structure

![](https://cdn-images-1.medium.com/max/558/0*x3kiI_mUHmf-dG2o)

#### Sample Code

An example Facade interface can be written as follows in Go:

```
type StockManager struct {
	readyStocks []ReadyStock
	hotStocks []HotStock
}

func (s *StockManager) GetStock(item Item) int {
	stock1 := findReadyStockOfItem(item, readyStocks)
	stock2 := findHotStockOfItem(item, hotStocks)
	return stock1 + stock2
}
```

The remaining code for sub-systems is omitted. We can still understand the pattern without it.

#### Testing

Given that this pattern primarily focuses on structuring types, testing is typically not required.

### Related Patterns

#### Singleton

Often, only one Facade is needed. So we can apply the Singleton pattern ensures this uniqueness.

#### Abstract Factory

Since each sub-system contains inter-related objects, the Abstract Factory pattern can assist in their initialization.

* * *