teleren/devto huggingface dataset:
Best SMM Service Provider- YouTube and Instagram Provider
Tags: bestsmmserviceprovider, smmpanel, socialmediamarketing, smmdepth
Published: 2023-03-25 10:44:06

There are several SMM Panels in Bangladesh that offer great services. However, the best SMM Panel for you will depend on your specific needs and preferences. Here are a few popular SMM Panels in Bangladesh that you can consider This is a popular SMM Panel in Bangladesh that offers a wide range of social media marketing services including Facebook, Instagram, YouTube, and Twitter. They provide high-quality services at affordable prices.high-quality services for Facebook, Instagram, Twitter, YouTube, and other social media platforms. They offer competitive prices and excellent customer support.Before choosing an SMM Panel, make sure to do your research and read reviews from other users to ensure you find the best fit for your needs.

[Best smm service provider](https://smmdepth.com)

If you're looking for a cheap SMM panel in Bangladesh, there are a few things to keep in mind. First, it's important to choose a panel that offers high-quality services at affordable prices. Second, you should look for a provider that has a good reputation and positive reviews from other customers. Finally, you may want to consider a provider that offers a range of social media services to help you achieve your marketing goals.
One option to consider is SocialPilot, a popular SMM panel in Bangladesh that offers a range of social media marketing services at competitive prices. They offer services for popular platforms like Facebook, Instagram, Twitter, and LinkedIn, as well as other services like SEO, PPC, and email marketing. They have a user-friendly interface and a helpful customer support team to assist you with any questions or concerns.
Another option is Buy Real Marketing, which is another affordable and reliable SMM panel in Bangladesh. They provide a range of social media services, including likes, followers, views, and comments, for platforms like Facebook, Instagram, Twitter, and YouTube. They also offer a money-back guarantee if you're not satisfied with their services.
In any case, it's important to do your research and choose a provider that meets your needs and budget. I hope this information helps you in your search for a cheap SMM panel in Bangladesh. Best of luck!
AI Ecommerce content generation
Tags: ecommerce, openai, webshop
Published: 2023-03-25 10:26:27

Check out our latest update on how you can utilize the Tinyshop OpenAI integration to quickly generate content outlines for the products in your webshop or generate completely new ones.

{% embed https://youtu.be/xS7-2HMf7jw %}

Learn more here: [Ecommerce AI Solution](https://tinyshop.cloud/docs/ecommerce-ai-solution)
How I Built My Personal Blog Site Using AWS Services
Tags: aws, devops, cloud, serverless
Published: 2023-03-25 10:24:37

Recently, I build my personal blog site using AWS services. It's a central place to add my every contribution. Ex - Medium & Dev.to articles, Youtube videos, etc.

My Personal Blog Site : [https://lasanthasilva.tech/](https://lasanthasilva.tech)

Basically, I used a .tech domain, static website hosting, and a lot of AWS services.

- S3
- CloudFront
- Route53
- Certificate Manager(ACM)
- Lambda
- APIGateway
- DynamoDB
- IAM 

I'm completed AWS Cloud Resume Challenge. [Link](https://cloudresumechallenge.dev/docs/the-challenge/aws/)

This is my Architectural Diagram

![aws-static-website-architectural-diagram](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9qf8bkmg1carpvcsawix.png)

You can use my git repository to get sample code.
Git [Repository](https://github.com/sanju2/personal_blog_website)

Let's start the challenge.

**Step 1.**
Build my blog site in HTML with CSS.

**Step 2.**
Created an S3 bucket to store portfolio files.

**Step 3.**
Create Route53 Hosted zone and add copy NS records. Next, paste the ns record domain provider nameservers section.

**Step 4.**
Next, go to the S3 bucket and enable Static website hosting, and map the Index document and Error document.

**Step 5.**
Requested a public certificate for your domain in AWS Certificate Manager(ACM).

**Step 6.**
Setup a CloudFront Distribution. Select S3 Static website hosting bucket endpoint and ACM public certificate.

**Step 7.**
Next, create a Lambda function for the Visitor Count display. Used Python 3.9 runtime.

**Step 8.**
Created DynamoDB table for Visitor count.

**Step 9.**
Created APIGateway REST API and Invoke Lambda function.

**Step 10.**
Create a git repository and push code.

**Step 11.**
Create GitHub Actions for deploying S3 static website files and Lambda function codes.

Finally, Push the latest release to Github.

These are the steps I used to build my personal blog site.

You can visit my blog site using this [https://lasanthasilva.tech/](https://lasanthasilva.tech).

Thanks for reading the Article.

_References_ https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html

_Connect With Me_

[LinkedIn](https://www.linkedin.com/comm/mynetwork/discovery-see-all?usecase=PEOPLE_FOLLOWS&followMember=lasanthasilva) 

[Twitter](https://twitter.com/LasanthaSilva96)
What is base64 attacks on websites?
Tags: security, webdev, discuss
Published: 2023-03-25 10:10:54

According to a report by the cybersecurity firm Imperva, SQL injection attacks, which can be carried out through Base64 encoding, are one of the most common types of web application attacks, accounting for 20% of all attacks. This indicates that Base64 attacks are a significant threat to websites and web applications.

Base64 is a common encoding technique that is used to convert binary data into ASCII text format. This encoding method is often used for transmitting data over the internet, including images, audio files, and other types of binary data. However, Base64 encoding can also be used maliciously to attack websites.

In a Base64 attack, an attacker uses a specially crafted input that is encoded in Base64 format to exploit vulnerabilities in a website's input validation and processing mechanisms. Once the attacker has successfully executed the attack, they can gain unauthorized access to sensitive data or take control of the website.

**_Here are some common examples of Base64 attacks on websites_**
➼ SQL injection: In this type of attack, an attacker injects Base64-encoded malicious code into an input field on a website, such as a login form or search box. When the website processes the input, the Base64-encoded code is decoded and executed, allowing the attacker to execute arbitrary SQL queries on the website's database.

➼ Cross-site scripting (XSS): In an XSS attack, an attacker injects Base64-encoded malicious code into a website's input fields, such as comment boxes or contact forms. When the website processes the input, the Base64-encoded code is decoded and executed, allowing the attacker to execute arbitrary scripts on the user's browser.

➼ Remote code execution: In a remote code execution attack, an attacker exploits a vulnerability in a website's code to inject Base64-encoded malicious code. The attacker can then execute the code on the website's server, allowing them to take control of the server and potentially gain access to sensitive data.

To prevent Base64 attacks on your website, it's important to implement proper input validation and sanitization techniques. This includes checking input for unexpected characters, encoding special characters, and filtering out potentially dangerous input.

In addition, you should regularly update your website's software and plugins to ensure that you have the latest security patches and bug fixes. You should also use strong passwords and two-factor authentication to protect your website's login credentials.

In conclusion, Base64 attacks on websites are a serious threat that can result in unauthorized access to sensitive data and other malicious activities. By implementing proper security measures and staying up-to-date with the latest security patches, you can help prevent these types of attacks and keep your website safe from harm.
Static configuration files generated using the gs_om tool
Tags: opengauss
Published: 2023-03-25 09:48:44

generate configuration file
Background Information
During the use of openGauss, if the static configuration file is accidentally damaged, it will affect the openGauss perception of the openGauss topology and the master-backup relationship. The static configuration file generated by the gs_om tool can replace the damaged configuration file to ensure the normal operation of openGauss.

Preconditions
none.

Steps
Log in to the active database node as the operating system user omm.

Executing the following command will generate a configuration file in the specified directory of the server.

gs_om -t generateconf -X /opt/software/openGauss/clusterconfig.xml --distribute
/opt/software/openGauss/clusterconfig.xml is the XML configuration file when openGauss is installed.

illustrate:

After the command is executed, the directory where the new file is stored will be displayed in the log information. Taking the environment of one master and two backups as an example, when you open the new file storage directory, three configuration files named after the host name will appear, and you need to use these three files to replace the configuration files of the corresponding hosts.

If you do not use the --distribute parameter, you need to perform step 3 to distribute the static configuration file to the corresponding node; if you use the --distribute parameter, the generated static configuration file will be automatically distributed to the corresponding node without performing step 3 .

(Optional) Replace the damaged static configuration files in the /opt/gaussdb/app/bin directory of the three hosts respectively.

Here we take one of the hosts as an example.

mv /opt/huawei/wisequery/script/static_config_files/cluster_static_config_SIA1000056771  /opt/gaussdb/app/bin/cluster_static_config
example
Execute the following command on any host in openGauss to generate a configuration file:

gs_om -t generateconf -X  /opt/software/openGauss/clusterconfig.xml --distribute
Generating static configuration files for all nodes.
Creating temp directory to store static configuration files.
Successfully created the temp directory.
Generating static configuration files.
Successfully generated static configuration files.
Static configuration files for all nodes are saved in /opt/huawei/Bigdata/mppdb/wisequery/script/static_config_files.
Distributing static configuration files to all nodes.
Successfully distributed static configuration files.
Open the generated configuration file directory, and you will see 3 newly generated files:

cd /opt/huawei/Bigdata/mppdb/wisequery/script/static_config_files
ll
total 456
-rwxr-xr-x 1 omm dbgrp 155648 2016-07-13 15:51 cluster_static_config_plat1
-rwxr-xr-x 1 omm dbgrp 155648 2016-07-13 15:51 cluster_static_config_plat2
-rwxr-xr-x 1 omm dbgrp 155648 2016-07-13 15:51 cluster_static_config_plat3
openGauss routine maintenance: check time consistency
Tags: opengauss
Published: 2023-03-25 09:36:20

Check time consistency
The consistency of database transactions is guaranteed by the logical clock and has nothing to do with the operating system time. However, inconsistent system time will cause many potential problems, mainly due to abnormal background operation and maintenance and monitoring functions. Therefore, it is recommended to check the time consistency of each node during monthly inspections.

Steps
Log in to the active database node as the operating system user omm.

Create a configuration file that records each node of openGauss (_mpphosts file directory_users can specify at will, it is recommended to put it under /tmp).

vim /tmp/mpphosts
Add the host name of each node.

plat1
plat2
plat3
Save the configuration file.

:wq!
Execute the following command to output the time on each node to the "/tmp/sys_ctl-os1.log" file.

for ihost in `cat /tmp/mpphosts`; do ssh -n -q $ihost "hostname;date"; done > /tmp/sys_ctl-os1.log
Confirm the time consistency of each node according to the output, and the time difference between nodes cannot exceed 30 seconds.

cat /tmp/sys_ctl-os1.log
plat1
Thu Feb  9 16:46:38 CST 2017
plat2
Thu Feb  9 16:46:49 CST 2017
plat3
Thu Feb  9 16:46:14 CST 2017
A Way To Improve Your Layout Building Process using CSS
Published: 2023-03-25 09:34:50

Well, Hi.

I don´t have too much time coding, but I find some things that I think improve my daily work, so I want to share it.

One of these things is the fact that you can make, for example: is create two css class say bg_test and bg_test_in that holds different background: properties colors of the background of the hole page and assign it to each container and it's children:

For example make the structure: container or wrapper and it's inside boxes. So the big containers will have de bg_test class(f. e. header, section, a div component container, etc..) and the children of these containers the bg_test_in(f. e. h1, span, p, a inside div, etc...) class. And then you just have to give a width and height property to each element to see how is fixing your layout adjust it to your needs. 

Another thing could be, make an estimate of which is the equivalent in pixels of 1 view port width and height(say 13,64px/7,4px per 1vw/1vh) and then convert your units to vw or vh to make it more responsive... In these matter I find that some times is better work only with vw cause is some one resizes the screen only in the horizontal line it will make distortion in your pattern. It's my appreciation at least.
 
It's pretty simple, but it make my life simple... So I hope it's help you.
Variables and Constants: Declaration and Usage
Tags: beginners, tutorial, programming, go
Published: 2023-03-25 09:27:54

#  Explanation of how to declare and use variables and constants in Go.


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

Go is a statically typed programming language that requires variables to be declared with a specific data type. Variables can be declared using the `var` keyword followed by the variable name and data type.

```
var age int

```

Here, `age` is the variable name and `int` is the data type. Variables can also be initialized with a value at the time of declaration.

```
var age int = 25

```

In Go, constants are declared using the `const` keyword followed by the constant name and value.

```
const pi = 3.14

```

Constants can also be declared with a data type.

```
const pi float64 = 3.14

```

There are multiple ways to declare variables and constants in Go:

- Declare and initialize a single variable or constant in a single statement.

```
var age int = 25
const pi float64 = 3.14

```

- Declare and initialize multiple variables or constants in a single statement.

```
var name, age = "John Doe", 25
const pi, gravity = 3.14, 9.81

```

- Declare and initialize a variable or constant using shorthand notation.

```
name := "John Doe"
const pi = 3.14

```

In Go, it is possible to use variables and constants in expressions and statements. Here is an example:

```
var radius float64 = 5.0
const pi float64 = 3.14

var circumference = 2 * pi * radius

```

In this example, the variable `circumference` is assigned the value of `2 * pi * radius`.

In summary, variables and constants are used to store and manipulate data in Go programs. Variables can be changed during the execution of a program, while constants cannot. To declare a variable or constant, we use the "var" or "const" keyword followed by the name and type/value. To use a variable or constant, we refer to its name in our code.
Choosing NestJS vs unopinionated ExpressJS
Tags: node, webdev
Published: 2023-03-25 09:24:45

As a developer, choosing the right framework to build your application can be a daunting task. You need to consider factors such as scalability, performance, reliability, maintainability and many more.

In recent years, NestJS has emerged as a popular framework for building scalable and efficient Node.js applications. In this blog post, we will explore the advantages of using NestJS over the bare ExpressJS.

**Scalability:**
NestJS is built on top of ExpressJS and adds a layer of abstraction which allows developers to easily build scalable applications. NestJS has built-in support for microservices architecture, allowing developers to easily divide their application into smaller, independent services. It also provides out-of-the-box support for WebSockets, GraphQL and gRPC, making it easier to build realtime and scalable applications.

**Modular architecture:**
One of the key features of NestJS is its modular architecture. NestJS allows developers to build applications using reusable and decoupled modules, making it easier to maintain and test the application. With its Dependency Injection (DI) system, NestJS also ensures better modularity and code reusability.

**TypeScript support:**
NestJS is built using TypeScript, which allows developers to use features such as classes, interfaces, and decorators to write cleaner and more maintainable code. TypeScript makes it easier to catch errors during development, and improves code readability and maintainability.

**Out-of-the-box features:**
NestJS provides a lot of out-of-the-box features that would otherwise need to be implemented manually using ExpressJS. NestJS comes with built-in support for authentication, validation, error handling, caching and a lot more, making it easier to build robust applications.

**Community support:**
NestJS has a thriving community of developers who contribute to the framework, making it more robust and feature-rich. The community provides a lot of resources and support for developers, making it easier to learn and use the framework.

In conclusion, although ExpressJS is still a great framework for building Node.js applications, NestJS provides a lot of advantages in terms of scalability, modularity, TypeScript support, out-of-the-box features, and community support. The choice ultimately depends on your project's requirements, but if you're looking to build scalable and maintainable applications with Node.js, NestJS is definitely worth considering.
NetworkX vs Apache Age: A Comparison of Two Python Graph Analysis Libraries
Published: 2023-03-25 09:14:02


**Introduction:**
Graph analysis has become increasingly important in many fields, including social network analysis, machine learning, and big data analytics. If you're looking to analyze graph data, two open-source libraries you may consider are NetworkX and Apache Age. In this blog post, we will explore the differences between these two libraries and discuss which one may be better suited for your specific needs.

**Section 1: What is NetworkX?**
In this section, we will introduce NetworkX and explain its features, use cases, and limitations in simpler terms. We will discuss its core features, such as creating and manipulating graphs, analyzing network structure, and visualizing networks. We will also cover its limitations, such as being limited by the amount of memory available on a single machine and being single-threaded.

**Section 2: What is Apache Age?**
In this section, we will introduce Apache Age and discuss its features, use cases, and limitations. We will explain its core features, such as being a distributed graph database and computation engine, supporting a graph query language, and handling large-scale graphs. We will also discuss its limitations, such as being a relatively new library with a smaller user base.

**Section 3: Differences between NetworkX and Apache Age**
In this section, we will compare NetworkX and Apache Age and explain their differences in features, use cases, and limitations. We will describe technical differences, such as how they store and process graphs, their scalability, and their query language support. We will also describe differences in their intended use cases, with NetworkX being a more general-purpose library and Apache Age being designed for large-scale graph analysis in the context of relational databases.

**Section 4: Which library to choose?**
In this section, we will provide guidance on which library to choose based on specific use cases. We will discuss scenarios where NetworkX may be more appropriate, such as when analyzing small to medium-sized graphs, and scenarios where Apache Age may be more appropriate, such as when analyzing large-scale graphs or when working with relational databases.

**Conclusion:**
In conclusion, both NetworkX and Apache Age are useful libraries for analyzing and manipulating graph data, each with its own strengths and limitations. By understanding their differences, users can make informed decisions on which library to choose based on their specific needs. Whether you're working with small or large-scale graphs or need to perform complex graph queries, there is a library out there that can help you achieve your goals.

[Apache-Age:-https://age.apache.org/](https://age.apache.org/)
[GitHub:-https://github.com/apache/age](https://github.com/apache/age)
Golang, concurrency - don't over-complicate life.
Tags: go, tutorial, architecture
Published: 2023-03-25 09:03:36

Web development is what I normally specialize in but now and then I have to drop to Golang for some CLI tool or specialized microservice.

I have never had the time to spend learning Golang properly, however having quite a bit of programming experience; Golang is a fairly easy language to pick up in a short space of time. Although to be honest, it's misleading in its simplicity - because as you dive deeper, you realize it's not so easy to master.

One of the things I realized over time, is that I have been overcomplicating concurrency in for loops. While looping I usually want to process the items using goroutines. 

Goroutines work fine however you cannot control how many goroutines you spawn in a loop, and further - if you don't use something like wait groups, the main function can exit, while these still run - which often, is not desirable.

I found a very cool and powerful package that is great and has many use cases, however for simple loops it's just overkill: https://github.com/alitto/pond

The general goal of Golang and, why I prefer it over other languages - is its minimalism and compact language design.

You can often do tasks natively in the language without external packages. Far too often in Python/PHP/JavaScript, we tend to pull in a package and just implement - which is not a bad thing, however, doing so can at times add more overhead and negatively impact performance as well.

Coming back to concurrency in for loops; while the pond library is great and you definitely should check it out - there is a native way in Golang to achieve controlled concurrency in for loops:

```golang
package main

import (
	"fmt"
	"sync"
)

func doSomethingWithUrl(url string, wg *sync.WaitGroup) {
	fmt.Println("Some implementation here...")
	defer wg.Done()
}
func main() {
	// Main will not wait for goroutines to finish, so use a waitGroup to stop the main from exiting.
	var wg sync.WaitGroup

	urls := []string{"https://example.com", "https://example2.com", "https://example3.com", "https://example4.com"}

	// How many tasks to do concurrently
	numWorkers := 2

	for i, url := range urls {

		// Every time we reach a goroutine count of numWorkers - pause the loop for those to finish.
		if i > 0 && i%numWorkers == 0 {
			wg.Wait()
		}

		wg.Add(1)
		go doSomethingWithUrl(url, &wg)
	}

	wg.Wait()
}

```
As you can see - it's slightly more verbose than using the pond library, however, we avoid an extra third-party dependency and, avoid features like channels that can add unnecessary overhead to our code.


Image credit: https://www.pexels.com/photo/close-up-shot-of-green-plant-8412830/