teleren/devto huggingface dataset:
no-code/low-code development platforms and AI
Published: 2023-05-29 19:19:53

Indeed, the combination of no-code/***low-code development platforms and AI (Artificial Intelligence)***can be a powerful and winning formula for accelerating application development and enhancing functionality. Let's explore the benefits of this combination:

Accessibility and Efficiency: No-code/low-code platforms allow individuals with little or no programming experience to build applications using visual interfaces and pre-built components. By incorporating AI capabilities into these platforms, developers can leverage pre-trained models, automated workflows, and intelligent algorithms, making application development faster and more accessible to a wider range of users.

Rapid Prototyping and Iteration: The visual nature of no-code/low-code platforms, combined with AI capabilities, enables quick prototyping of AI-powered features and functionalities. Developers can easily experiment with different AI models, algorithms, and data sources to build intelligent applications. This iterative approach allows for faster feedback and validation of ideas, leading to accelerated development cycles.

Intelligent Automation: AI integration with no-code/low-code platforms empowers applications with automation capabilities. Developers can leverage AI to automate repetitive tasks, data analysis, decision-making processes, and even natural language processing. This combination enables the creation of intelligent workflows and systems that enhance productivity and efficiency.

Enhanced User Experience: AI technologies like natural language processing, computer vision, and machine learning can be seamlessly incorporated into no-code/low-code applications. This integration enables the development of intelligent interfaces, personalized recommendations, chatbots, voice-enabled functionalities, and other AI-driven features that enhance the user experience and make applications more intuitive and interactive.

Bridging the Skills Gap: No-code/low-code platforms, when combined with AI capabilities, allow non-technical users to leverage AI functionalities without deep knowledge of AI programming or data science. This bridge between technical and non-technical domains enables collaboration and innovation, empowering users from different backgrounds to contribute to AI-powered applications.

By combining the ease of use and accessibility of no-code/low-code platforms with the power and capabilities of AI, developers can create sophisticated applications with AI-driven features and functionalities more efficiently. This winning formula promotes innovation, accelerates development cycles, and opens up opportunities for a broader range of individuals to leverage AI in their applications.
Swag Lab Automation Testing Project [Selenium, Java]
Tags: selenium, java, automaton, testing
Published: 2023-05-29 19:10:41

For this project, I developed a model and I have used these libraries,
▶️ Selenium
▶️ Java

Presentation Video
{% embed https://youtu.be/x2DzI_NE9p0 %}

Any suggestions are welcomed!
**Thanks For Reading**😄
SDL2 (Simple DirectMedia Layer 2) vs SDLC :
Published: 2023-05-29 18:59:00

SDLC **Software Development Life Cycle** and SDL2 (Simple DirectMedia Layer 2) are two completely different concepts related to software development.
SDLC (Software Development Life Cycle)
SDLC is a framework that outlines the processes and stages involved in software development. It provides a structured approach to software development, ensuring that the development process is well-defined, organized, and manageable. SDLC typically consists of the following phases:
Ordered list Requirements gathering and analysis
Design
Implementation (coding)
Testing
Deployment
Maintenance and support
SDLC serves as a guideline for software development teams, helping them deliver high-quality software products by following a systematic approach and addressing potential risks and challenges throughout the development cycle.

SDL2 (**Simple DirectMedia Layer 2**):
SDL2 is a software library used for developing multimedia applications and games. It provides a cross-platform development framework that abstracts low-level multimedia functionalities, such as graphics, audio, and input, making it easier for developers to create software that runs on multiple platforms.
SDL2 offers a range of features and functions that simplify the development of multimedia applications, including window management, rendering graphics, handling input devices, playing audio, and more. It supports various programming languages such as C, C++, and Python, and is widely used in the game development industry.
In summary, SDLC is a methodology for managing the overall software development process, while SDL2 is a software library used for multimedia application development. They are distinct concepts with different purposes within the software development field.
JavaScript wants your functions to have names
Tags: javascript, webdev, beginners
Published: 2023-05-29 18:54:34

JavaScript function names can be quite helpful for debugging and logging, but how does JavaScript determine what a function's name *is*?

## JavaScript functions have a `name` property

The first thing to note, since it's not at all obvious, is that JavaScript functions are special kinds of *objects* with a few default properties:

```js
function myFunction(){};
console.log(Object.getOwnPropertyNames(myFunction));
// [ 'length', 'name', 'prototype' ]
```

One of those properties is the `name` field. That's where your function's name is stored.

## Function names are *readonly*

If we take a named function and look at its `name` property descriptor, we see that it is readonly:

```js
function myFunction(){};
console.log(Object.getOwnPropertyDescriptor(myFunction, 'name'));
// {
//   value: 'myFunction',
//   writable: false,
//   enumerable: false,
//   configurable: true
// }
myFunction.name = 'anotherName'; // TypeError: Cannot assign to read only property 'name' of function 'function myFunction(){}
```

Notice that the `name` property is *configurable* by default. So while we can't directly re-assign the name using an assignment operation, we can still use [`Object.defineProperty`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty) to rename a function:

```js
function myFunction(){};
Object.defineProperty(myFunction, 'name', {writable: true, value: 'myRenamedFunction'});
console.log(myFunction.name); // myRenamedFunction
```

## JavaScript *wants* to name your functions

You can explicitly name a function by using the `function myFunctionName(){}` syntax. But when you don't use that syntax, e.g. with arrow functions or with "anonymous" `function(){}` declarations, JavaScript will still try to find a name to give to your function.

If you've declared your function on the right-hand-side of an assignment, the name of the variable on the left is used as the name:

```js
const myFunction = function(){};
console.log(myFunction.name); // myFunction

const myArrowFunction = () => {};
console.log(myArrowFunction.name); // myArrowFunction

const myObject = {
  myMethod: function(){},
  myArrowMethod: () => {}
};
console.log(myObject.myMethod.name); // myMethod
console.log(myObject.myArrowMethod.name); // myArrowMethod
```

## Do "anonymous" JavaScript functions even exist?

No, not really. If you create an "anonymous" function that also isn't directly assigned to a named variable, you can get an "anonymous" function:

```js
const anonymousFunctionGenerator = ()=>()=>{};
const myAnonymousFunction = anonymousFunctionGenerator();
console.log(myAnonymousFunction); // [Function (anonymous)]
```

BUT! The function *does still have a name*, it's just a sneaky one: an empty string!

```js
const anonymousFunctionGenerator = ()=>()=>{};
const myAnonymousFunction = anonymousFunctionGenerator();
console.log(Object.getOwnPropertyDescriptor(myAnonymousFunction, 'name'));
// { value: '', writable: false, enumerable: false, configurable: true }
```
My Frustration With Web Components.
Tags: webdev, webcomponents, html
Published: 2023-05-29 18:51:40

> **TLDR**: I want to tool to build and bundle a HTML file (with `<template>` and `<script>` into a single JS file

I have a bone to pick with Web Components at the moment. Mainly tooling around bundling and the overall experience of creating them. All which lead to a hit in performance when using them.

One use case I come back to over and over is a markdown editor. I've cobbled together a working version of a `simple-mde` web component. You can see it for yourself in [this gist](component). It's loosely based off this 5-year-old [repo here](https://github.com/Shridhad/wc-simplemde) — a repo filled with outdated build tools, gulp and bower.

The format for this component is fairly straightforward. It includes a `<template>` with a single nested `<style>` tag. And a single `<script>` tag that creates the `HTMLElement` and adds it to the DOM. The issue with this code is that both the CSS and JS have external dependencies, totaling 4. They load from CDNs, which comes with its host of pros and cons. At this point, we've agreed that it's best practice to pull down and minify all of this.

To make matters worse, the way I've built this file in HTML is unusable. There's no standard way to include HTML within a document. A couple of years back, browsers teased us with being able to do `<link rel="include" href="/component.html">`, which doesn't work anymore, is impossible to even find ever existed on the internet. [Here's a post](https://www.jotform.com/blog/html5-imports-import-html-files-into-html-files-83467/) about it. Of course, this functionality can still be added via custom code.

But what I want is a way to take the WORKING file I created above for my `simple-mde` web component and convert that HTML file to a bundled and minified JS file. I want all of the dependencies to be bundled into the file, the `<template>` code to be converted to a string, and automatically add it to the DOM when the file loads. Finally, the `<script>` tag would be removed. All of this can be bundled as a single JS file, so the entire component is contained.

Why don't we have a way to bundle web components this way? 😤
HTML tags get rendered in post titles in DEV. - `<code>`.
Tags: bug, dev, watercooler, webdev
Published: 2023-05-29 18:49:58

Check out [*HTML `<a>` tag gets rendered as HTML instead ov being written as text in the notification menu.*](https://github.com/forem/forem/issues/19553) for more information.
<br/>
<br/>
Under certain circumstances, it seems likes certain HTML will be rendered; to my knowledge, this only works for the [`<a>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a)-tag, as demonstrated here:
![[Image ov the bug.]](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xb33ys7c7jhkvl99rx6a.png)
The true title ov the post is [*How can I remove the "padding"-like stuff on the `<a>`?*](https://dev.to/baenencalin/how-can-i-remove-the-padding-like-stuff-on-the--12fp) (ov course, without the tag being in a code snippet, but rather wrapped in two backticks).

I conducted an experiment to see if it would happen again, and even this post will be an experiment, but it turns out it does not seem to happen with a `<code>` tag; however, the setup was different, so that could have threw off the results.
![[Image ov the bug not happening.]](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y48s7z4cv3nkw1glvk7x.png)



<center><b>Thanks for reading!<br/>Cheers!</b></center>
Insertion Sort
Tags: programming, computerscience, algorithms, csharp
Published: 2023-05-29 18:32:53

Insertion Sort is a sorting algorithm that operates in a way similar to the process by which many people sort cards in their hands during a game. It simply takes one element at a time and inserts it into the correct position within the already sorted list, moving all subsequent elements.

## How it works

The functioning of the algorithm can be summarized in the following steps:

1. It starts from the second element (index 1 in zero-based array), considering the first element as already sorted.
2. It takes the current element and compares it with all preceding elements in the array.
3. If the current element is smaller than its predecessor, it swaps the two elements and continues to compare with all other preceding elements.
4. This process continues until the current element is larger than its predecessor or until it reaches the beginning of the array, indicating that the current element is the smallest in the array up to that point.
5. It moves on to the next element in the array and repeats the process until all the elements in the array have been sorted.

Here is a simple implementation in C#:

```csharp
public void InsertionSort(int[] arr)
{
    var len = arr.Length;
    
    for (var i = 1; i < len; i++)
    {
        var key = arr[i];
        var j = i - 1;

        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j = j - 1;
        }

        arr[j + 1] = key;
    }
}
```

## Time complexity

In the worst case and average case, the time complexity is O(n²), where n is the number of elements in the array. This means that the execution time increases quadratically with the size of the input. However, in the best case (when the array is already sorted), it has a time complexity of O(n).

## Space complexity

Being an in-place sorting algorithm, its space complexity is O(1), meaning that memory usage does not increase with input size. Simply put, it does not require additional space to sort the data.

## Conclusion

Insertion Sort is an excellent example of the variety of sorting algorithms. Although it may not excel in large data set situations because of its quadratic time complexity, its unique strengths certainly shine in particular scenarios.

First, its simplicity in terms of understanding and implementation makes it an excellent teaching tool for those new to the world of algorithms.

Second, when dealing with small data sets or near-sorted data sets, Insertion Sort can be surprisingly efficient and even outperform more complex algorithms.

Third, its stability-the property of preserving the relative order of equal elements-and its in-place nature are advantageous in certain situations.

Finally, sorting by insertion performs exceptionally well when data is received in real time. It can maintain an ordered list as new items are inserted, making it an excellent choice for scenarios where it is useful to have a continuously ordered view of the data.

## References

- Algoritmi e programmazione in C di Francesco Oliveri, Aracne editrice (Italian book)
DeprecationWarning: crypto.createCipher is deprecated.
Tags: node, webdev, beginners, tutorial
Published: 2023-05-29 17:55:24

Support for both `crypto.createCipher` & `crypto.createDecipher` has been pulled as they use a weak key derivation function (MD5 with no salt) and static initialization vectors (iv).

Here, we'll work with migrating from `crypto.createCipher` & `crypto.createDecipher' to `crypto.createCipheriv` & `crypto.createDecipheriv`

Let's begin with the basics. Run the following command in parent directory of your node.js project.

`npm install crypto --save`

## Encryption

Make sure that the secret key & secret initialization vector is set correctly with required length. To keep the format intact we use `createHash` from crypto.

Here is the code below:


var Crypto = require('crypto')
var secret_key = 'fd85b494-aaaa'
var secret_iv = 'smslt'
var encryptMethod = 'AES-256-CBC';
var key = Crypto.createHash('sha512').update(secret_key, 'utf-8').digest('hex').substr(0, 32);
var iv = Crypto.createHash('sha512').update(secret_iv, 'utf-8').digest('hex').substr(0, 16);
var encryptMsg = encryptStr("Encrypting", encryptMethod, key, iv);
console.log(encryptedMsg);

function encryptStr(plain_text, encryptMethod, secret, iv) {
   var encryptor = Crypto.createCipheriv(encryptMethod, secret, iv);
   var aes_encrypted = encryptor.update(plain_text, 'utf8', 
 'base64') + encryptor.final('base64');

   return Buffer.from(aes_encrypted).toString('base64');
};


## Decryption

Here is the code below:

var Crypto = require('crypto');
var secret_key = 'fd85b494-aaaa';
var secret_iv = 'smslt';
var encryptMethod = 'AES-256-CBC';
var decryptMessage = decryptStr(encryptText, encryptionMethod, key , iv);
console.log(decrptMessage);


function decryptStr(encryptText, encryptMethod, secret, iv) {
  const buff = Buffer.from(encryptText, 'base64');
  encryptedMessage = buff.toString('utf-8');
  var decryptor = Crypto.createDecipheriv(encryptMethod, secret, iv);
  return decryptor.update(encryptText, 'base64', 'utf8') + decryptor.final('utf8');
};

References:
[Crypto|Node.js v20.2.0 Documentation](https://nodejs.org/api/crypto.html)
Apitable.com Net6 Rest Api
Tags: api, core, csharp, opensource
Published: 2023-05-29 17:52:47

You can see the Github from here
[https://github.com/mesutde/Apitable.RemoteUrlControl.Net6.Rest.Api](https://github.com/mesutde/Apitable.RemoteUrlControl.Net6.Rest.Api)


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


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



For this project , I have used these technologies

- C#
- Linq
- Rest-Api
- Swagger


Presentation Video
{% embed https://www.youtube.com/watch?v=SbFo7gJ8-Ww %}
some approaches to scrape the clutch-page: with bs4 and pandas - a comparison
Tags: webdev, python, apache, pandas
Published: 2023-05-29 17:48:15


trying to gather the data form the page "https://clutch.co/il/it-services" 
and that said i - think that there are probably several options to do that

a. using bs4 and requests
b. using pandas

this first approach uses a. 


```
    import requests
    from bs4 import BeautifulSoup
    import pandas as pd
    
    url = "https://clutch.co/il/it-services"
    response = requests.get(url)
    
    soup = BeautifulSoup(response.content, "html.parser")
    
    company_names = soup.find_all("h3", class_="company-name")
    locations = soup.find_all("span", class_="locality")
    
    company_names_list = [name.get_text(strip=True) for name in company_names]
    locations_list = [location.get_text(strip=True) for location in locations]
    
    data = {"Company Name": company_names_list, "Location": locations_list}
    df = pd.DataFrame(data)
    
    df.to_csv("it_services_data.csv", index=False)
```

This code will scrape 

a.  the company names and locations from the specified webpage and
b.  stores them in a Pandas DataFrame. 
c. It will then save the data to a CSV file named "it_services_data.csv" in the current working directory.


i am wondering if a panda-approach could be useful as well?


```
    import pandas as pd
    
    url = "https://clutch.co/il/it-services"
    
    # Use pandas to read HTML content and extract tables from the webpage
    tables = pd.read_html(url)
    
    # Assuming the desired table is the first one on the page
    table = tables[0]
    
    # Extract the columns we're interested in
    df = table[["Company Name", "Location"]]
    
    # Optional: Clean up the column names if needed
    df.columns = ["Company Name", "Location"]
    
    # Optional: Perform further data processing or analysis using the Pandas DataFrame
    
    # Save the data to a CSV file
    df.to_csv("it_services_data.csv", index=False)

```
In this approach, pandas' read_html() function is used to read the HTML content of the webpage and extract tables. 
Assuming the desired table is the first one on the page, we are able to assign it to the table variable. 
Then, we can extract the columns we're interested in and create the DataFrame. 
Finally, we are able to perform further data processing or analysis if needed and save the data to a CSV file.
Docker Crash Book [FREE] 🎉 🐳| Just Enough Docker to be a Docker Ninja
Tags: docker, tutorial, javascript, beginners
Published: 2023-05-29 17:41:58



By the end of this short book, you will have enough understanding of the concepts to get started and a **great overall big picture of how Docker** is used in the whole software development process.

The book is available as a website at [https://www.omkar.cloud/docker/](https://www.omkar.cloud/docker/) 🤓


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ntk8wzf1fxlgmlv3t3vw.png)
### ▬▬▬▬▬▬ BOOK CONTENTS 📚 ▬▬▬▬▬▬

1. Introduction
2. Docker
3. Container and Image
4. Dockerization
5. Volume

---

Read the book at [https://www.omkar.cloud/docker/](https://www.omkar.cloud/docker/)

> I am an IITian with a perfectionist attitude to work, open to projects. See my projects at [https://dev.to/chetanan/chetan-jains-portfolio-cl6](https://dev.to/chetanan/chetan-jains-portfolio-cl6)
Setting up an Alias for a Directory in Apache2 Server
Tags: apache2, linux, environment, localhost
Published: 2023-05-29 17:40:38

In most Apache installations, the default root directory is typically located at `/var/www/html` on Linux systems. This means that the `index.html` file should be placed in the `/var/www/html` directory for it to be served as the default file when accessing the web server.

When you develop something in your apache2 server that time this `var/www/html` directory might not be suitable for you. So if you can alias your directory where you want to develop or write your program it will help you develop your program. 

First, check that is your apache2 server active or not using `service apache2 status`. If apache2 server is stopped then activate apache2 server using this command `service apache2 start`

Open `apache2.conf` file in your vs code editor using this command - `code /etc/apache2/apache2.conf`.
Hope, you will find this code below - 
```
<Directory /var/www/>
	Options Indexes FollowSymLinks
	AllowOverride None
	Require all granted
</Directory>
```
Bellow this code add your code which alias your custom directory location. 

```
Alias /yoursite /yourDirectory
<Directory /yourDirectory>
    Options Indexes FollowSymLinks
    AllowOverride None
    Require all granted
</Directory>
```
For better understanding, I share my settings. Hope you will understand now. 

```
Alias /local-wp /home/sajiudr/all-wp
<Directory /home/sajidur/all-wp>
    Options Indexes FollowSymLinks
    AllowOverride None
    Require all granted
</Directory>
```

Now, restart your apache2 server using this command `service apache2 restart`. Then check apache2 server status `service apache2 status`.

If you create a file `index.html` in `yourDirectory` you can show this in your browser to hit this link `http://localhost/yoursite`.

Hope you will understand. If you face any problem please comment bellow my post. 

Happy coding, fellow Devs! Until next time, bye and keep building amazing things!
DexCoyote Foundation will allow the issuance of crypto-tokens in the TON network
Tags: foundation
Published: 2023-05-29 17:22:22


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q6a4gc9zqgsk389oyshy.jpeg)
<p>DexCoyote has announced an update with the integration of the TON blockchain. <a href="https://dexcoyote.com">DexCoyote</a> decentralized tools provide the ability to create, promote and sell tokens within 12 blockchain networks (Binance Smart Chain, Ethereum, Polygon and others). Creating a token and listing it on DexCoyote is free, no liquidity or collateral is needed. Any transactions go through smart contracts in the blockchain in a couple of seconds.</p>
<p>The integration of TON will allow the project to attract the attention of new users, as well as additional investments and grants from the TON ecosystem itself.</p>
<p>After the update, any user without experience, programming knowledge and costs will be able to create their own cryptocurrency token in the TON network, manage it, gather a community and, of course, sell the token itself.</p>