teleren/devto huggingface dataset:
Post bootcamp
Tags: bootcampgrad
Published: 2023-06-12 19:16:53

Wow, it's been a while since I've been on here. Right now, I'm 3 months post bootcamp graduation. It's been hard to stay motivated on this job search but I'm getting my fire back and I'm now more motivated than ever!

I haven't been coding much for around 2 months (I wish I was lying) but right now, I'm updating my portfolio and working on a cookbook website that I pushed to the side a while ago. 

Monday is my favorite day of the week so I'm enjoying the day and I'm praying that I'm prepared for anything this week has to bring. Happy Monday!
Clarity
Tags: 100daystooffload, clarity, web, analytics
Published: 2023-06-12 19:11:56

I have used [hotjar](https://www.hotjar.com/) once on a web project and found that tool to be very insightful. Now I stumbled over this tool, [Clarity](https://clarity.microsoft.com/), from Microsoft that seems to do about the same thing.

From the site:

_Clarity is a cutting-edge behavioral analysis tool that helps you understand user interaction with your website. By using Clarity's robust analysis tools, you can enhance your website for your clients and your business._

and it's a free service forever (wonder what free means here though?).

It seems to have interaction heatmaps on the site, session recordings and a nice dashboard with a lot of information.

Hoping to get some time soon to try it out.
How to build your own Firebase console
Tags: firebase, dashboard, tutorial, developers
Published: 2023-06-12 19:11:01

Hey folks!

I wanted to jump in and share something cool with you all. Have you ever wondered why building your own Firebase console is worth it? Let me break it down for you!

Firebase is a powerful platform that offers a range of features to supercharge your app development journey. But here's the kicker: by building your own Firebase console, you can take complete control of your app's backend management and unlock a whole new level of flexibility and customization.

So, why should you consider it? Well, let me tell you:

**Tailored to your needs:** By building your own Firebase console, you can design it to perfectly fit your app's specific requirements. No more dealing with unnecessary clutter or features that don't align with your workflow. It's all about creating a console that speaks your language!

**Streamline your workflow:** With a custom Firebase console, you can streamline your app management tasks like a pro. From monitoring user analytics to configuring push notifications, you'll have all the tools at your fingertips to efficiently handle your app's backend processes.

**Enhance user experience:** A personalized Firebase console allows you to provide a seamless experience to your app users. You can effortlessly manage user data, authenticate users, and deliver personalized content, making their interactions with your app smooth and delightful.

**Advanced automation:** With your own Firebase console, you can automate repetitive tasks and free up valuable time for more critical development work. Imagine setting up scheduled functions, automated backups, and data synchronization with ease. It's a developer's dream come true!

Now, you might be wondering how to get started with building your Firebase console. Well, good news! DronaHQ a low code app development platform offers you everything that is required to build an amazing Firebase console.

Leap and empower yourself with the full potential of Firebase by building your console. Trust me, it's a game-changer! Head over to https://www.dronahq.com/firebase-console/ to dive deeper and unlock a world of possibilities.

If you have any questions or want to share your experiences with Firebase, feel free to drop a comment below. Let's geek out together and discover the endless opportunities Firebase brings to the table!
How to Easily Change VSCode Color Theme
Tags: vscode, productivity
Published: 2023-06-12 19:06:05

In this video I will show you how to easily change VSCode color theme with an extension called Peacock. This extension changes the color of the title bar, status bar and activity bar.

Once installed the extension can be accessed from the command palette. Simply open the command palette and search for peacock. You can select from a list of predefined favorite colors. You can darken or lighten a selected color.  You can even save a favorite color.

This extension is great for identifying different VSCode windows at a glance. If you work with other developers  and do not want to commit your color settings you can easily remove and reapply your changes when switching between branches.

To learn more check out the wonderful documentation at https://www.peacockcode.dev/guide/#overview 

https://marketplace.visualstudio.com/items?itemName=johnpapa.vscode-peacock

{% embed https://youtu.be/xmeV31LE0R8 %}
Make something old better or make something new that's (possibly) worse?
Tags: programming, discuss
Published: 2023-06-12 19:01:57

From time to time I work on Quail which is (or rather was) an instant messaging client based on libpurple using the Qt toolkit.

It has pretty much been abandoned for 9 years and the little bit of work I've put in so far was mostly just fixing some bugs I experienced when testing it. I'd like to continue working on it in the little bit of spare time I have although I don't really have a clear idea where I want to go with this.

In its current state, Quail lacks many features of its big brother Pidgin and is very unstable. Segmentation faults are not uncommon and some widgets don't even show up like they're supposed to.

I personally find the GUI not very convenient to use. I think it inherited the GUI from [qpe-gaim](https://qpe-gaim.sourceforge.net/) which it is based on and which was Gaim running on PDAs. If I were to continue working on Quail I would probably change the GUI to be more like Pidgin's GUI.

So there's actually not that much speaking in favour of continuing to work on Quail. My off work programming time would probably be better spent on starting something new from scratch (but also libpurple based) or contribute more to Pidgin to help bringing version 3 about sooner. The problem with the latter is that working with C and GLib feels more like a chore to me rather than actually being fun. Fixing bugs and reviewing code of Pidgin is fine but I don't see myself contributing new features to it.

On the other hand I already have a name in mind to give to my new IM client, so what's stopping me really? ;)
Discovering Variable Arguments (varargs) in Java
Tags: java, tutorial, programming, learning
Published: 2023-06-12 19:01:50

### What are variable arguments(varargs)?

Variable arguments is a feature in Java that allows us to create methods that can accept zero or multiple number of arguments
of a specified type. Before java 5, you could not declare a method with a variable number of arguments. If the number of arguments for the method were to change then you would need to declare a new method.

For example,

```
public void aMethod(int a)
{
	//some method body
}
```

the function **aMethod** has only one argument. Say we wanted to call **aMethod **with more than one argument, the options we would have was to create overloaded methods, pass an array as an argument or declare a new method with the number of arguments needed. 
In the event where we do not know the number of arguments that are going to be passed a better approach would be to use the varargs feature.

### Varargs implementation

The syntax for declaring a method with variable arguments is using the ellipses notation("**...**") after the datatype. Internally this feature is implemented as an array, so you would handle the varargs the same way you would handle an array

Below is the syntax

```
public void aMethod(String... arguments)
{
	for (String argument : arguments)
        {
             // some code handling
        }
}
```

Now for a practical example.
Imagine you are planning a party and you want to gather preferences from your friends regarding the food they would like to have. Each friend may have a different number of food options they want to suggest. Varargs can be used in this scenario to handle the varying number of suggestions from each person.

Implementing this in code will look like this
```
public static void gatherFoodPreferences(String... foodOptions) {
    System.out.println("Food preferences:");
    for (String option : options) {
        System.out.println("- " + option);
    }
}
```
We can call this method with a different number of arguments depending on the options each person suggests
```
gatherFoodPreferences("Pizza", "Burger");
gatherFoodPreferences("Pasta", "Fried rice", "Fried Chicken");
```
The method will iterate over each argument and print out each food option. This allows us to gather different opinions and options without having to explicitly define the exact number of options upfront.

<u>Some rules to note when implementing varargs</u>

1. You can only have one variable argument in a method.
2. If there are other arguments in the method the variable argument  has to be declared as the last argument.
Software Quality Factors
Tags: webdevelopemnt, sqa, softwaretesting, qualityassurance
Published: 2023-06-12 19:00:00

Software quality factors, also known as software quality attributes or software quality characteristics, are the measurable aspects of software that determine its overall quality and effectiveness. These factors help assess the software's ability to meet user expectations, perform reliably, and deliver the desired functionality. Here are some commonly recognized software quality factors:

1. Functionality: Functionality refers to the software's ability to provide the desired features and meet the specified requirements. It includes correctness, suitability, accuracy, interoperability, and compliance with standards.

2. Reliability: Reliability measures the software's ability to perform consistently and predictably under various conditions. It includes factors such as fault tolerance, recoverability, availability, and error handling.

3. Usability: Usability focuses on the ease of use and user experience provided by the software. It includes factors such as learnability, efficiency, intuitiveness, and user satisfaction.

4. Efficiency: Efficiency relates to the software's ability to perform tasks quickly and effectively while utilizing minimal system resources such as memory and processing power.

5. Maintainability: Maintainability assesses the software's ease of maintenance and future enhancements. It includes factors such as modularity, readability, reusability, and comprehensibility of the code.

6. Portability: Portability measures the software's ability to be easily adapted and deployed across different platforms, operating systems, and environments.

7. Testability: Testability refers to the software's ease of testing and the effectiveness of test cases in ensuring its quality. It includes factors such as observability, controllability, and isolatability of components for testing purposes.

8. Security: Security focuses on protecting the software from unauthorized access, data breaches, and vulnerabilities. It includes factors such as confidentiality, integrity, availability, and authentication.

9. Scalability: Scalability measures the software's ability to handle increasing workloads and user demands while maintaining its performance levels. It includes factors such as load balancing, resource allocation, and system capacity.

10. Compatibility: Compatibility assesses the software's ability to interact and integrate with other systems, software components, and devices. It includes factors such as data format compatibility, API compatibility, and backward compatibility.

These factors are not exhaustive, and additional factors may be considered based on specific software domains or industry requirements. Evaluating and ensuring these quality factors during the software development lifecycle contribute to the overall success and acceptance of the software in its intended environment.
terminal-style personal website
Tags: webdev, portfolio, showdev, react
Published: 2023-06-12 18:53:43

## A template of personal website
I build a **macos terminal-style personal website** by React.
You can download the template and build your own portfolio page.

![Demo](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1rs293vbnpj7sygnnt3g.png)

![Demo](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vqbq2qktg8408ot8kqx2.png)

Put your own image and introduction!
View the project on github [profile-site](https://github.com/chi-0828/profile-site)
My journey from Vim/Neovim to VS code 🥺
Tags: vim, vscode, opensource, humor
Published: 2023-06-12 18:36:36

> Disclaimer: potential standard-inclined content, reader discretion advised.

The following anti-monkeypatch standard-inclined mindset originated from the frustrations from prolonged exposure to and usage of semi-standard technologies, e.g. code editors, operating systems, desktop workspace, etc.

Opensource is good. As a movement to empowering developers, enabling innovations, and receiving critique to gradually agree on an industry standard - there is _simply_ no alternative of opensource. Our world runs on opensource! However the aspect of opensource regarding its very nature, that is, most opensource projects do not receive the funding they deserve and may lack a strong leadership to govern the project. **This may yield a project deficit in supporting its ever-evolving consumer base.** Opensource software projects witnessed tremendous success in the early ages of commercial computer software - this is beyond doubts. However in the contemporary era, in which the complexity, diversity, and expectations of software is vital - **a distinction is to be made** between FAANG-backed or Fortune 500-backed opensource initiatives and other individual/communitarian ones.

<hr>

This was a regular day in the life of mine as a Software Engineer - however, yet again, I caught myself searching for decentralized extensions individually developed on an average of 9 years ago for Vim/Neovim. Similar to Visual Studio Code, however... _(checking vscode vs vim user count worldwide...)_

_(In a survey of 86,544 responses...)_

| Code editor | % Users |
|-------------|---|
| Visual Studio Code | 73.71% |
| Visual Studio | 28.43% |
| IntelliJ IDEA | 26.82% |
| Vim | 22.29% |
| Neovim | 11.86%|

... more likely that, Visual Studio Code extensions will be better 🙃. Plus, centralized "verified" extension support provide an upper hand in some cases.

In reddit, a question was asked, why shouldn't I use Vim? Arguments against Vim. The first reply received 92 upvotes. Feb 2019.
> _"Every once in a while you'll go through the rabbit hole of addng something cool, configuring another plugin, or changing colorscheme/syntax - **that you forget doing actual productive work.**"_

(This is too true! May I be forgiven! Unbelievable! Feels sad!)

One of the reply to the first reply was:
> _"That's why I started relearning vanilla Vim. Native Vim. Without plugins. For Java, Go, Swift - I use JetBrains products with ideavim [a plugin that enables Vim keybindings]."_

I almost feel like taking one step further,
> _"I may just use Visual Studio Code, instead of Vim. Maybe Windows 11, instead of a Linux distribution that was created by a guy over a decade ago. Maybe the magic developed by JetBrains. Maybe Slack, instead of Matrix. Maybe Microsoft 365 w/ Copilot, instead of LibreOffice. These are products well-built and polished and proven through rigorous testing and extensive real-world usage._

> _Maybe, just maybe, I need to learn to appreciate professionals investing their time and life and company to build these incredible, impossible products."_
DAY 9 - Candy Distribution Problem
Tags: programming, learning, cpp
Published: 2023-06-12 17:44:54

Hey. You are reading day-9 of the 100 Days Challenge. This is Nayan Pahuja.
Today we are going to solve another problem that are solved using greedy algorithms.

Let's get right on to it.
PS:- While I am writing this article, Leetcode seems to be under maintenance for the moment. I will update the code of this question back when I get a chance.

## DAY 9 Problem 1: Candy Distribution Problem[](https://leetcode.com/problems/candy/)
_The problem states that distribute the minimum number of candies to N children such that:_

- Each child must have at least one candy.
- The children with a higher ranking will get more candies than their neighbors.

_Note that each child has a rating. The task is to the minimum number of candies you must give._

## Intuition:
The problem is rather easy for being a leetcode hard problem. There is not much to sweat. Let's note down our observation and clear a misconception first.

All Children have must 1 candy.
All children must be compared with both of it's neighbors before updating it's candies.
It must have a higher rating than both of it's neighbors not equal to but higher.

## Approach:

- We will solve this by passing the ratings array 2 times.
- One from left to right and another traversing back from right to left.

- We will first initialize a vector of integer having value 1. This array will be used to store the candies of each child per their rating.
- Then we will traverse through ratings from left to right incrementing the count of that index's child's candies greater than it's successor's if it satisfies the conditions.
- Then while returning back from right to left. We will check the same condition for its left neighbors but will also check if it already satisfies the conditions of being greater than it's neighbors. 
- If it satisfies these conditions, we shall increment it by 1 else we shall not.

## Code:

```

int candy(vector<int>& ratings) {
        //extreme cases
        if(ratings.size() == 1)
        {
            return 1;
        }
        int n = ratings.size();
        vector<int> totalCandies(n,1);
        for(int i = 1; i < n; i++)
        {
            if(ratings[i] > ratings[i-1])
            {
                totalCandies[i] = totalCandies[i-1]+1;
            }
        }
        for(int i = n-2; i > -1 ; i--)
        {
            if(ratings[i] > ratings[i+1] && totalCandies[i] <= totalCandies[i+1])
            {
                totalCandies[i] = totalCandies[i+1]+1;
            }
        }
        int sum = 0;
        for(int i = 0; i < n; i++)
        {
            sum = sum + totalCandies[i];
        }

        return sum;
        
    }
```

**Complexity Analysis**

> Time Complexity: O(N) + O(N) ~= O(N).
> Space Complexity: O(N)
A Prática de "Fritar Pastel" no Mundo do Software: Uma Analogia Falha
Published: 2023-06-12 18:13:53

Na gestão de projetos e no desenvolvimento de software, é comum ouvirmos analogias curiosas utilizadas para simplificar complexidades. Uma delas é a comparação entre fritar um pastel e desenvolver um software. Essa analogia geralmente surge quando um Proprietário de Produto (Product Owner - P.O.) subestima a complexidade e o tempo necessário para o desenvolvimento de um software, acreditando que é tão simples e rápido quanto fritar um pastel. No entanto, essa analogia é, em muitos aspectos, falha.

## Compreendendo a Complexidade do Desenvolvimento de Software

Ao contrário de fritar um pastel, que é um processo direto e linear, o desenvolvimento de software é um processo complexo que envolve várias etapas interdependentes. Desde a definição dos requisitos, passando pelo design, codificação, teste e manutenção, cada etapa requer tempo, habilidade e consideração cuidadosa. Além disso, muitos destes passos precisam ser repetidos em ciclos até que o produto final esteja pronto.

## A Importância do Tempo no Desenvolvimento de Software

Fritar um pastel é um processo que leva apenas alguns minutos. Por outro lado, desenvolver um software requer significativamente mais tempo. Mesmo as tarefas de desenvolvimento aparentemente simples podem levar horas, dias ou até mesmo semanas, dependendo da complexidade do requisito. É fundamental que os Proprietários de Produto entendam e respeitem o tempo necessário para o desenvolvimento de software.

## A Falácia da Pressa no Desenvolvimento de Software

Assim como fritar um pastel em fogo alto pode resultar em um produto queimado por fora e cru por dentro, tentar acelerar o desenvolvimento de software pode levar a um produto final de baixa qualidade. Bugs, problemas de desempenho e uma experiência ruim do usuário são comuns quando o desenvolvimento é apressado.

## Reconhecendo a Expertise Necessária

Enquanto a habilidade para fritar um pastel pode ser aprendida rapidamente, tornar-se um desenvolvedor de software competente requer anos de estudo e prática. Desenvolver software não é apenas sobre escrever código, mas também sobre entender a lógica, resolver problemas e, acima, tudo ter uma compreensão clara das necessidades do usuário final.

Portanto, é crucial que os P.Os, assim como todos os envolvidos na gestão de projetos de software, compreendam a complexidade inerente ao desenvolvimento de software. Ao fazer isso, podemos evitar mal-entendidos e garantir que os projetos sejam gerenciados de maneira mais eficaz.
Building a Photography site in Angular
Tags: webdev, angular, aspdotnet, azure
Published: 2023-06-12 17:54:24

I'm new here, so hopefully I'm doing this right. I've been spending my free time working on my side hustle as a photographer and decided to marry the two by building myself a new website.
https://jessecarlbergphotography.com
My current stack is: 
Angular 16,
Angular Material, 
Bootstrap, 
Asp.net, 
Entity Framework,
SQL Server and Mongo DBs, 
Image and Media CDN on Azure,
all above hosted on Azure Cloud. 
I'm building out a user management and auth system now to share galleries and photos, etc. 
I thought I'd document some of the progress and share it as I go. Let me know if there's any specific interests I should focus on.
My most recent addition was theming if you're interested check it out in my walkthrough here:
https://jessecarlbergphotography.com/news/648731df22607f04324d6ffa

But I'm looking for suggestions on cool features I should build out!
Why I started to learn coding as a teacher
Tags: coding, beginners, python
Published: 2023-06-12 17:50:13

Finished my first text adventure in Python today! Not a huge project, but I got it done after quite some practice at Codecadamy. I started to work on the course Computer Science a few weeks ago, in my free time. In my first life, I am a teacher for History and English for grades 5-13. In this post I would like to write about the decision to pursue this new path - and what I hope to accomplish.

The digital world never was part of the curriculum at university or later at school. At the same time, it has become an integral part of the children's (and also mine) life. To know how to navigate and even to manipulate it is now more important than ever - especially if one want to be successful in the workplace. 

So right now, coding is a way for me to be a better, a modern teacher - and to help my students to navigate this world better. Can't wait to see what it has in store for me, too!

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