teleren/devto huggingface dataset:
CSS vs SASS!
Tags: css, sass, webdev, beginners
Published: 2023-01-24 12:47:06

When it comes to styling web pages, there are a few different options to choose from. One of the most popular is CSS (Cascading Style Sheets), but another option that's gained traction in recent years is SASS (Syntactically Awesome Style Sheets). In this post, we'll take a closer look at the differences between these two styling options and help you decide which one might be the best fit for your next project.

First, let's talk about CSS. CSS is a stylesheet language used for describing the presentation of a document written in a markup language, like HTML. It's used to apply styles such as colors, fonts, and layouts to web pages. CSS is a widely-used and well-supported option, and it's the standard for styling web pages. It's simple to learn, and there are a wide variety of resources available online to help you get started.

While CSS is a great option, it can become cumbersome as the size and complexity of your project increases. This is where SASS comes in. SASS is a preprocessor for CSS that adds features such as variables, nested rules, and mixins (reusable blocks of styles). These additional features make SASS a more efficient and organized option for styling large and complex projects.

One of the biggest advantages of SASS is its use of variables. With CSS, if you want to use the same color or font throughout your website, you'll need to use the same value repeatedly. With SASS, you can define a variable for that value and use it throughout your stylesheet, making it much easier to make global changes.

Another advantage of SASS is its use of nested rules. In CSS, you need to repeat the parent element for each child element you want to style. With SASS, you can nest child elements within their parent elements, making your stylesheet more readable and easier to maintain.

Mixins are another powerful feature of SASS. They allow you to define a block of styles that can be reused throughout your stylesheet. This can save you a lot of time and effort when you need to apply the same styles to multiple elements.

Once you've written your SASS code, it needs to be compiled into standard CSS before it can be applied to your web page. This might sound like an extra step, but it's actually quite simple to set up, and there are many tools available that make the process even easier.

In summary, CSS is a popular and well-supported option for styling web pages. It's simple to learn and use, but it can become cumbersome for large and complex projects. SASS is a preprocessor for CSS that adds features such as variables, nested rules, and mixins, making it a more efficient and organized option for styling large and complex projects. Ultimately, the choice between CSS and SASS will depend on the size and complexity of your project, as well as your personal preferences.
i18n and i18next: What's the difference?
Tags: i18n, internationalization
Published: 2023-01-24 12:45:39

For many, this question has a pretty clear answer, but people, who are new to software development or who started to use i18next as the first choice, can be mistaken. So let's make it clear!

## What is i18n?​

The better question would be "What does i18n stands for". i18n is the abbreviation of the word internationalization, where the " 18" stands for the number of letters between the first i and the last n.

## What is internationalization?​

It's the process of designing the software application so that it can be adapted to various languages and regions. What does it mean? It means that when you are using some i18n/localization library or if you have your application prepared to be translated to different languages, you are doing internationalization. Yay! 🎉

## What is i18next?​


`i18next` is an internationalization framework written in and for JavaScript. It's a library you integrate into your application code. `i18next` helps you to render different strings for users speaking different languages.

## So what is the difference?​

`i18n` is an abbreviation that is used across all the programming languages and software development world. `i18next` is a JS framework/set of libraries.

## i18next is not a standard​

Although i18next is currently used by many developers, it's not a standard. It has a nice catchy name and if you google i18n, you can get the i18next website as a first result, but there are plenty of other libraries for JavaScript you can use. Here are some of them:

[FormatJS](https://formatjs.io)

[react-intl (a react i18n library from FormatJS family)
](https://formatjs.io/docs/react-intl/)

[Tolgee JS (Our integrations)
](https://tolgee.io/integrations)

[Typesafe-i18n
](https://github.com/ivanhofer/typesafe-i18n)

i18next is not the only solution out there. Different solutions suit different needs.

## TL;DR​

i18n is the abbreviation for internationalization
i18next is a JavaScript framework enabling internationalization
Cyber Security Landing Page Design Using Figma + Responsive + Auto Layout | Figma Tutorial
Tags: figma, beginners, webdev, tutorial
Published: 2023-01-24 12:44:00

{% youtube 8UOq9wDt0Io %}

Support us and GET 10% OFF of your next order in my shop using the code: EARLYBIRD 🙏❤️
https://my-store-d97fa0.creator-sprin...

Hi guys, today we want to show How To create a Cyber Security Landing Page Design Using Figma + Responsive + Auto Layout | Figma Tutorial
Please, if you love it, support us with Like & Subscribe.🙏🙏❤️❤️

Download File :
https://www.figma.com/community/file/...

Let's be friends and connect
📩 Subscribe:https://shorturl.at/BCTV8
📷 Instagram: https://www.instagram.com/soudemy/
📱 Behance: https://www.behance.net/soudemy
🐦 Twitter: https://twitter.com/SoudemyAcademy

In the comments, you can say what design you want so that we can prepare the video for you.
5 Things You Might Didn't Know About Julia Tuples
Tags: programming, beginners, tutorial, julialang
Published: 2023-01-24 12:43:08

**1)** Tuples in Julia can contain elements of different types. For example, you can create a tuple that contains a mix of integers, strings, and floating-point numbers.

```julia
julia> my_tuple = (1, "hello", 3.14)
(1, "hello", 3.14)
```
  

**2)** Julia allows you to use the push!() function to add an element to the end of a tuple. This function modifies the tuple in place and returns nothing.

```julia
julia> my_tuple = (1, 2, 3)
(1, 2, 3)
julia> push!(my_tuple, 4)
julia> my_tuple
(1, 2, 3, 4)
```

**3)** You can compare two tuples element-wise using the == operator. This returns a tuple of boolean values, one for each element of the tuple.

```julia
julia> my_tuple1 = (1, 2, 3)
(1, 2, 3)
julia> my_tuple2 = (1, 2, 4)
(1, 2, 4)
julia> my_tuple1 == my_tuple2
(true, true, false)
```

**4)** Julia provides a zip() function that can be used to combine the elements of two or more tuples into a new tuple of tuples.

```julia
julia> my_tuple1 = (1, 2, 3)
(1, 2, 3)
julia> my_tuple2 = ("a", "b", "c")
("a", "b", "c")
julia> zip(my_tuple1, my_tuple2)
((1, "a"), (2, "b"), (3, "c"))
```

**5)** You can use the popfirst!() and poplast!() functions to remove the first and last elements of a tuple, respectively. These functions modify the tuple in place and return the removed element.

```julia
julia> my_tuple = (1, 2, 3)
(1, 2, 3)
julia> popfirst!(my_tuple)
1
julia> my_tuple
(2, 3)
julia> poplast!(my_tuple)
3
julia> my_tuple
(2,)
```

**Note** that it is important to keep in mind that these functions modify the tuple in place, so if you want to keep the original tuple you should create a copy before using these functions.
Exploring Julia Tuples: Methods, Operations, and Examples
Tags: julialang, programming, tutorial, beginners
Published: 2023-01-24 12:33:55

Julia is a high-performance programming language for technical computing, with syntax that is familiar to users of other technical computing environments. One of the core data structures in Julia is the tuple, which is an ordered collection of elements. In this blog post, we will explore the different methods and operations that can be performed on tuples in Julia.

**Creating a Tuple**

A tuple in Julia can be created using the parentheses () operator. For example, the following code creates a tuple of integers:

```Julia
julia> my_tuple = (1, 2, 3)
(1, 2, 3)
```

You can also create a tuple using the Tuple() function, like this:

```Julia
julia> my_tuple = Tuple(1, 2, 3)
(1, 2, 3)
```

**Accessing Tuple Elements**
You can access the elements of a tuple using indexing, like this:

```Julia

julia> my_tuple = (1, 2, 3)
(1, 2, 3)
julia> my_tuple[1]
1
julia> my_tuple[2]
2
```

You can also use the first(), second(), etc. functions to access specific elements of the tuple, like this:

```Julia
julia> my_tuple = (1, 2, 3)
(1, 2, 3)
julia> first(my_tuple)
1
julia> second(my_tuple)
2
```

**Tuple Concatenation**
You can concatenate two or more tuples using the * operator, like this:

```Julia
julia> my_tuple1 = (1, 2, 3)
(1, 2, 3)
julia> my_tuple2 = (4, 5, 6)
(4, 5, 6)
julia> my_tuple3 = my_tuple1 * my_tuple2
(1, 2, 3, 4, 5, 6)
```

**Tuple Length**
You can get the number of elements in a tuple using the length() function, like this:

```Julia
julia> my_tuple = (1, 2, 3)
(1, 2, 3)
julia> length(my_tuple)
3
```

**Tuple Iteration**

You can iterate over the elements of a tuple using a for loop, like this:

```Julia
julia> my_tuple = (1, 2, 3)
(1, 2, 3)
julia> for i in my_tuple
           println(i)
       end
1
2
3
```

**Tuple Unpacking**

You can unpack the elements of a tuple into separate variables using the = operator, like this:

```Julia
julia> my_tuple = (1, 2, 3)
(1, 2, 3)
julia> a, b, c = my_tuple
julia> a
1
julia> b
2
julia> c
3
```

In conclusion, Tuples in Julia are a powerful and versatile data structure that can be used to store and manipulate ordered collections of elements. The methods and operations discussed in this blog post should
Setting up a Document Database with Amazon DocumentDB (with MongoDB compatibility) and AWS Cloud9
Tags: aws, cloud, awscommunity, 100daysofcloud
Published: 2023-01-24 12:28:56

[24/100] #100DaysOfCloud Today, I created a DocumentDB and learnt how to connect to your Amazon DocumentDB cluster from your AWS Cloud9 environment with a mongo shell and ran a few queries.

Amazon DocumentDB (with MongoDB compatibility) is a fully managed native JSON document database that makes it easy and cost effective to operate critical document workloads at virtually any scale without managing infrastructure. Amazon DocumentDB simplifies your architecture by providing built-in security best practices, continuous backups, and native integrations with other AWS services.
As a document database, Amazon DocumentDB makes it easy to insert, query, index, and perform aggregations over JSON data.

<u>Use cases :</u>
- Store and query content management data
 - Improve the customer experience through fast, reliable access to reviews, images, and other content stored in your content management system (CMS).

- Manage user profiles, preferences, and requests
 - Generate customer recommendations and enable online transactions. Manage millions of user profiles and preferences.

-  Scale mobile and web applications
 - Build applications that scale to process millions of user requests per second with low-latency global reads.

You can try do it by yourself by following the steps from the link below:
[GitHub](https://github.com/aaditunni/100DaysOfCloud/blob/main/Journey/024/Readme.md)
A tmux plugin to make creating/switching sessions easier
Tags: tmux, productivity, programming, github
Published: 2023-01-24 12:19:52

## Tmux session wizard

<img width="500" alt="tmux-session-wizard" src="https://user-images.githubusercontent.com/14043848/195257556-bc2cfe0a-a1c7-4e29-9741-776eaf0caa06.png">


One prefix key to rule them all (with [fzf](https://github.com/junegunn/fzf) & [zoxide](https://github.com/ajeetdsouza/zoxide)):
- Creating a new session from a list of recently accessed directories
- Naming a session after a folder/project
- Switching sessions
- Viewing current or creating new sessions in one popup

## Elevator Pitch

Tmux is powerful, yes, but why is creating/switching sessions (arguably its main feature) is so damn hard to do? To create a new session for a project you have to run `tmux new-session -s <session-name> -c <project-folder>`. What if you're inside tmux? Oh, wait you have to use `-d` followed by `tmux switch-client -t <session-name>`. Oh, wait again! What if you're outside tmux and you want to attach to an existing session? now you have to run `tmux attach -t <session-name>` instead. What if you can't remember whether you have a session for that project or not. Guess what? Now you have to run `tmux has-session -t <session-name>`. What if your project folder contains characters not accepted by tmux as a session name? What if you want to show a list of existing sessions? You run `tmux list-sessions`. What if you want to create a session for a project you've recently navigated to? What if, what if, what if.... HOW IS THAT BETTER THAN HAVING 20 TERMINAL WINDOWS OPEN?

What if you could use 1 prefix key to do all of this? Read on!

## Features

`prefix + T` (customisable) - displays a pop-up with [fzf](https://github.com/junegunn/fzf) which displays the existing sessions followed by recently accessed directories (using [zoxide](https://github.com/ajeetdsouza/zoxide)). Choose the session or the directory and voila! You're in that session. If the session doesn't exist, it will be created.

## Get the plugin

Install from https://github.com/27medkamal/tmux-session-wizard
8 Advanced Typescript Features web developer should know
Tags: webdev, typescript, programming
Published: 2023-01-24 12:15:16

Unlike Javascript, Typescript can identify errors or mistakes at the early stage of the development process (at compile time). It can save time by reducing efforts to change code when issues arise after running the applications.

Here are the 8 advanced Typescript features you will learn in this post.

1. Decorators
2. Type Inference
3. Generics
4. Enums
5. Namespaces
6. Tuples
7. Conditional Types
8. Advanced Types

For detailed explanations with examples, check out [canopas' blog](https://blog.canopas.com/8-advanced-features-of-typescript-a-deeper-dive-into-the-language-cb630b1079e2).
CIN & VARIABLES.
Tags: webdev, programming, python, devops
Published: 2023-01-24 12:11:44

Bugungi darsimizda siz bilan `cin`,`variables`yani kiritish chiqarish haqida gaplashib chiqamiz.

`cin>>`bu qiymat kiritish uchun ishlatiladigan maxsus buyruq.
bu yerda nima boʻlayotganini tushuntiraman.


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

**6-qatordan** boshlab tushuntiraman, 
**6-qatorga** kelganda, `string` tepadagi, `ism` deb nomlanuvchi oʻzgaruvchiga, xotiradan **4bayt** joy ajratadi ammo lekin biroq uni ichi bosh turbdi, hali uni ichida hech nima yoʻq va 
**6-qatorni** tugatgandan keyin keyingi qatorga **7-qatorga** oʻtadi va `cin` buyrugʻini koʻradi `console`, `inpu`t va undan keyin qanday oʻzgaruvchi turgan boʻlsayam va `console` da qanaqa maʼlumot kiritishini kutib turadi va u malumotni kiritib **ENTER** ni bosgandan keyin, oʻsha kiritilgan malumoti, `ism` degan oʻzgaruvchi uchun berilgan qiymat boʻladi deb tasavvur qiladi komputer va undan keyin **7-qatordan** pastida qayerida 
`ism `soʻzini koʻrsa uni biz `console`ga qanday malumot kiritsak oʻsha malumoti keladi.


```css
#include <iostream>  
using namespace std;  
int main() {  
  int ism;
  cin>>ism;
  cout<<ism;
   return 0;  
   }  
```

Siz ko'rib turgan quyidagi dasturda ham `RUN` ni bosib natijasi ko'rishingiz mumkin.


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

Mana biz kutgandek `consule`da biz nimani kiritsak shuni `ism`
deb nomlangan o'zgaruvchining o'rniga qo'yib chiqarib berdi.

@dawroun
I don't know what to write on my blog - developer
Tags: writing, blog, bloggin
Published: 2023-01-24 12:00:00

Blog about little new things you discover, if it's new to you, it may also be new to others

Should you write a blog for it? For me.. the answer is always yes.

People have different reasons to write a blog. You may do it for ads, to connect with others, to practice your English (like me!) or improve your writing skills.

## "But.. what should I blog about ?"
This a question that everyone who wants to start blogging will face.  Even someone who already blog for a while, will question this again as well. You may call it "writer's block".

## I blog something when it's new to me
This is my not-so-secret formula. I write something that's new for me. Now it puts me on the opposite side, where I have too much to write since there are many things I don't know yet.

Here are more concrete things you could write

## How do you solve your bug
If you're like the 99,99% of us, you'll have a bug in your application. When you finally solved it, why don't you share it with the rest of us?

I often got a similar if not the exact same bug. Now.. instead of exploring google results pages, I can go to my blog and easily search for it.

If the solution you found is from Stackoverflow, Github issue or other people's site, don't forget to give a link/reference to it.

## When Documentation is not clear
There are many frameworks and libraries out there, but often they come without good documentation.

You can write what you just found on your blog.

If it's an open source, you can contribute to that project by improving the docs.

## Combine things together
Normally, you don't solve your problem by visiting one article / one q-n-a section on Stackoverflow. But you combine it with multiple resources.

Now it's your time to stitch these things together and present them to your reader. 

Let's say you're looking at "how to auto-delete files on AWS S3 that are older than a day". You may find:
- how to list things from AWS S3
- how to filter items that are created older than today in AWS S3
- how to remove multiple items on AWS S3
as separate articles/documentation. 

We can help the next people, that have the exact same case as us, by writing this step-by-step in one go.

Write it, then the search engine will help you distribute it.

## Today I learn ...
If you're learning something new, then it's a perfect chance to put down the things you learn that day. 

## BUT YOU DON'T MASTER IT YET!
The good news is your blog is not official documentation! feel free to write a disclaimer or information that you're currently learning about this topic and use your blog to help.

Writing something you learn, will help you along the way. (Read "remember" chapter on -Building a Second Brain-)

## Remember
If it's new to you, then it may also be new to others

--- 


If you are interested in the topic of teaching programming, be sure to subscribe to [fromdevtodev](https://fromdevtodev.com/)
Understand The Concept Of User Acceptance Testing
Tags: user, acceptance, testing
Published: 2023-01-24 11:58:48

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vw1j3w591s8rhnn59a9s.jpg)
Earlier it was seen that the testing procedure used to take up a lot of time to process. But now with the help of UAT, things have become easier and less complicated. The User Acceptance Testing from the Opkey test automation platform is enabling with the process that verifies a solution that will work for every user.

UAT is the type of procedure that can be done in the starting, middle, and even at the end of the software implantation, at every stage, UAT will provide the best services altogether. Today UAT is being used in many businesses on a daily basis. It helps in reducing all the unwanted frustrations and irritation among the users to get the best results.

In the management of the business, there are so many things that need to be handled very well. The use of manual testing will not serve the purpose of the business. Rather, working with UAT will provide the best services. Nowadays many developers look forward to UAT to get the best results. There will be no such need for a lot of time and effort to perform testing procedures.

The launch of the User Acceptance tool will help in providing the proper management of even complicated tasks simultaneously. There are many benefits of using UAT. Let’s have a look at them.

- UAT is one such testing procedure that can easily demonstrate all the software-required functions. This testing procedure is very popular in real-world work. The acceptance testing will surely focus a lot on the software performance and make sure that it is properly aligned with the system to provide the best results.

- This piece of testing software is available at very affordable prices which make it very easy for a lot of businesses to take the best from it. The work of UAT is verified by so many verified users that have stated that this provides optimal opportunities to just quickly identify all the broken features altogether. This way the use of UAT will help in saving a lot of time and effort which can be used in undertaking testing procedures.

- UAT will always provide quality reviews which are very useful for all the stakeholders to secure a healthy return on the investment. The maintenance cost of this system is quite low and the functionality is quite adaptive.

You can easily use UAT in different forms in business work. For the best UAT services, go to the Opkey platform which was founded in 2016 by three lifelong friends. After spending a lot of time in their career, they realised that existing automation tools were not that good enough in working. So they focused on coming up with the type of automation tool which is quite user-friendly and provides the best results.

The main goal of this platform is just to help all their clients with the most effective solution that can simplify their business procedures. With time Opkey has become one of the largest enterprises that can successfully tackle ERP migrations, updates, and deployment.
To integrate Mixpanel with NestJS
Published: 2023-01-24 11:30:13

To integrate Mixpanel with NestJS, you can use the official Mixpanel JavaScript library and install it via npm:

Install the Mixpanel library:

```
npm install mixpanel-browser --save
```


Create a module for Mixpanel by running the following command:

```
nest generate module mixpanel
```

In this Mixpanel module, import the Mixpanel library and add it to the imports array:

```
import { Mixpanel } from 'mixpanel-browser';

@Module({
  imports: [
    Mixpanel
  ]
})
export class MixpanelModule {}


```


In the component where you want to use Mixpanel, import the Mixpanel service and initialize it with your Mixpanel token:

```
import * as mixpanel from 'mixpanel-browser';
import { Injectable } from '@nestjs/common';
import AppConfigService from '../../config/app/configuration.service';

@Injectable()
export class MixpanelService {
  constructor(private readonly configService: AppConfigService) {}

  init(userToken: string): void {
    mixpanel.init(this.configService.mixPanelToken);
    mixpanel.identify(userToken);
  }

  track(id: string, action: any = {}): void {
    mixpanel.track(id, action);
  }
  people(id: string, action: any = {}): void {
    mixpanel.people(id, action);
  }
}

```
To track an event, use the track method:

```
  constructor(
    private readonly mixpanelService: MixpanelService,
  ) {}
```

example track:
```
      this.mixpanelService.init('UZI');
      this.mixpanelService.track('Signup', {
        $first_name: 'Uz',
        $last_name: 'Oz',
        $created: new Date().toISOString(),
        plan: 'premium',
      });
```

To set user properties, use the people.set method:

```
this.mixpanelService.people.set({
  "$email": "joe@example.com",
  "$first_name": "Joe",
  "$last_name": "Smith",
});
```


You can also use identify method to identify user with unique ID

```
this.mixpanelService.identify("13793");
```


That's it! You have now integrated Mixpanel with your NestJS app using a dedicated Mixpanel module. You can find more information on Mixpanel's official documentation.