teleren/devto huggingface dataset:
How to build an Acronym Generator in Python
Tags: python, codenewbie, programming, beginners
Published: 2021-02-04 08:49:56

Hey everyone, today we are going to create a simple **Acronym Generator using Python**.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/aaff34gfted4ryh7vjo1.png)

## How Acronym Generators work?

So basically an Acronym Generator will take a String as an input and it will return the initials of all the words in the String.

## Let's Code

To get started, we need a phrase from the user. We can do that using **`input()`** method.

```python
user_input = input("Enter a phrase: ")
```

We have stored the user input in a **`user_input`** variable.

Now we must ignore words like **'of'** from the user input as most of the time, **'of'** is not considered for acronyms.

Also, we need to separate each word and store it individually in a form of a list so that we can easily iterate through it.

```python
phrase = (user_input.replace('of', '')).split()
```

Here in **`user_input.replace('of', '')`** we are using **`.replace()`** function to ignore 'of' from the input, if any.

And then we are using **`.split()`** function to break down the string into individual words and store them as a list in **`phrase`** variable.

We are almost done!

We need an empty string variable to store our acronym. Let's quickly create one...

```python
acronym = ""
```

Now let's create a for loop which will iterate through **`phrase`** variable.

```python
for word in phrase:
	acronym = acronym + word[0].upper()
```

Here in **`acronym = acronym + word[0]`**, we are slicing off the first letter of words stored in **`phrase`** using slicing operator and adding it to our **`acronym`** variable.

We are also using **`.upper()`** function to capitalize the acronyms.

Finally, just add a **`print`** statement which will print out the acronym on the console.

```python
print(f'Acronym of {user_input} is {a}')
```

Awesome now let's try running our code with different inputs.

```bash
Enter a phrase: machine learning
Acronym of machine learning is ML
```

```bash
Enter a phrase: artificial intelligence
Acronym of artificial intelligence is AI
```

```bash
Enter a phrase: federal bureau of investigation
Acronym of federal bureau of investigation is FBI
```

## Source Code

You can find the complete source code of this project here - [mindninjaX/Python-Projects-for-Beginners](https://github.com/mindninjaX/Python-Projects-for-Beginners/tree/master/Acronyms%20Generator)

## Support

Thank you so much for reading! I hope you found this beginner project useful. 

If you like my work please consider [Buying me a Coffee](https://buymeacoff.ee/mindninjaX) so that I can bring more projects, more articles for you.

[![](https://dev-to-uploads.s3.amazonaws.com/i/5irx7eny4412etlwnc64.png)](buymeacoff.ee/mindninjaX)

Also if you have any questions or doubts feel free to contact me on [Twitter](https://twitter.com/mindninjaX), [LinkedIn](https://www.linkedin.com/in/mindninjax/) & [GitHub](https://github.com/mindninjaX). Or you can also post a comment/discussion & I will try my best to help you :D
YouTua - Download Videos/Playlists in your preferred Format and Quality..
Tags: python, productivity, github, git
Published: 2021-02-04 08:43:03

## What I built:
YouTua is a GUI Program to download videos/playlists from various [supported sites](https://github.com/dhhruv/YouTua/blob/master/Supported%20Sites.txt). It requires the Python interpreter, version 2.6, 2.7, or 3.2+, and it is not platform specific. It should work on your Unix box, on Windows or on macOS.


### Screenshots:
![YouTua Working Screenshot](https://user-images.githubusercontent.com/72680045/106863834-15916880-66ef-11eb-9178-22f23c2693a4.PNG)

### Description:
- YouTua is a GUI Program to download videos/playlists from various [supported sites](https://github.com/dhhruv/YouTua/blob/master/Supported%20Sites.txt). Using this software you can download videos from various supported websites for any purposes. It can be used by journalists and human rights organizations to save eyewitness videos, by educators to save videos for classroom use, by Uploaders to save backup copies of their own uploaded videos, and by users worldwide to watch videos on hardware that can’t run a standard web browser, or to watch videos in their full resolution over slow or unreliable Internet connections.
 
### GitHub Link:
{% github dhhruv/YouTua no-readme %}

### Permissive License:
- MIT License

### How To Use !
1. Select the OUTPUT Folder by manually adding path or selecting the FOLDER using the SELECT FOLDER Button.<br>
(By Default the OUTPUT FOLDER is set to the current directory.)
2. Enter the Link of Video you want to download.
3. Select the Format to download the video (mp4/mkv/webm).
4. Select the Quality in which you want to download the video (144p to 2160p).<br>
(If your preferred Quality is not available then the lower best quality will be downloaded.) 
5. To download the available subtitles check the subtitles button.
6. Click START DOWNLOAD and enjoy.<br>

## Background:
- I've seen over the past time that students need to download videos regarding there lectures because the Internet connectivity in many areas is still too slow to watch live lectures and so to make an app that is easy to use and they can download videos according to their preferred quality with minimal data loss. That thing inspired me to make something which can be useful and make some difference.

### How I built it:
- During the making of this software, I learned many new things in Python programming language including scrapping and many other aspects in the same domain. I'm still working on making it even better and easy to use. Next feature will be to download and extract audio file from the URL.

[Download YouTua.exe for Windows](https://github.com/dhhruv/YouTua/releases/download/2.0.0/YouTua.exe)
Data Mining
Tags: datascience, database, beginners, bigdata
Published: 2021-02-04 08:36:28

### What is data mining? 
Data mining is a process of extracting useful data from large set of raw data or process of discovering patterns in large data set. Data mining is also known as knowledge discovery in data. (KDD)

### Use of data mining
•	Automatic summarization of data
•	Extracting useful information
•	Discovering patterns in raw data

### Applications of data mining
•	Relational marketing
•	Fraud detection
•	Risk evaluation
•	Text mining
•	Web mining 

### Steps in data mining
**Data gathering and integration:** once the objectives and definition is identified, gathering of data begins as data comes from different sources therefore may requires integration. Data integration is a process of combining all gathered data into a single view.

**Exploratory analysis:** This is a third phase of data mining process. In this process, integrated data is investigated and summarized in main characteristics. It helps to identify errors and understand pattern in data before any assumptions.

**Attribute Selection:** This is a process of selecting attributes for integrated and summarized data. Here attributes that are n little use are removed to cleanse dataset. Moreover, new required attributes are added which are obtained from original attributes.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/hdsp9xq3tlxkji59xtvk.png)

**Model development and validation:** once high quality dataset with newly added attribute is obtained, models are developed. In this phase data is split into two subsets training and testing.
Training set which is relatively small is use to identify learning model and testing set is use to access the accuracy model generated using training set.

**Prediction and interpretation:** this is final process of data mining where developed models and implemented and used to achieve goals.

Data mining process includes feedback cycles, represented by dotted arrow in figure. which indicates return in previous phase depending on outcome of subsequent phase.

### Major issues in datamining:
•	Efficiency of data mining algorithm
•	Relational and complex types of data
•	Poor data quality
•	Presentation and visualization of mined data
•	Interactive mining of knowledge

### Data mining tools:
• [Oracle data miner](https://www.oracle.com/database/technologies/datawarehouse-bigdata/dataminer.html)
• [Rapid miner](https://rapidminer.com/)
• [IBM SPSS modeller](https://www.ibm.com/in-en/products/spss-modeler)
• [Weka](https://www.cs.waikato.ac.nz/ml/weka/)
• Many more...

Hope you found it informative :)
Transition Shorthand 🦔
Tags: css, tutorial, codenewbie, todayilearned
Published: 2021-02-04 08:30:46

Hey coding people, hope you guys doing well in your journey!

This post is a part of our "21 Days of CSS animation post"

{% link https://dev.to/atulcodex/20-days-of-css-animation-post-3g8d %}

In this post we'll learn about "transition shorthand" means a shortcut of transition property. 

{% codepen https://codepen.io/atulcodex/pen/poNJZwp %}

Take a look at this formula and you will understand the whole story.

**Longhand Formula**

![Longhand Formula](https://dev-to-uploads.s3.amazonaws.com/i/xn09u9z5dk0nuxj51il9.png)

**Shorthand Formula**

![Shorthand Formula](https://dev-to-uploads.s3.amazonaws.com/i/f6v78oueulgbkmgntppi.png)

That's all for this post And if you are interested to learn CSS you can join [Eduonix E-Learning platform](https://www.eduonix.com/UHJvZHVjdC0xMzE1MDIw).
Animated Neon Signs With SVG and CSS
Tags: css, svg, neon
Published: 2021-02-04 08:25:44

In this article, I'll show some of the techniques I used to create this sign:

{% codepen https://codepen.io/barhatsor/pen/vYXdVEj default-tab=result %}

First off, we need to get an SVG. In this case, the popper.

I used [The Noun Project](https://thenounproject.com), which is a large collection of SVGs you can use for free. [Here's the SVG I used.](https://thenounproject.com/term/party-popper/84215/)

Now that we have the SVG, let's make it glow!

We'll create a duplicate of the popper, put it behind the popper, and blur it.

{% codepen https://codepen.io/barhatsor/pen/vYyNvgX default-tab=result %}

First, we create an SVG `<filter>` with an ID of `glow-red`.

```HTML
<svg>
  <defs>
      <filter id="glow-red" height="122%"></filter>
  </defs>
</svg>
```

Then, we define the filter, setting it to blur using `<feGaussianBlur>`, and changing the blur radius with the `stdDeviation` property.

```HTML
<feGaussianBlur stdDeviation="5"> 
```

We also add some additional properties that control the position (`dx`, `dy`) and color (`flood-color`) of the blur.

```HTML
<feOffset in="blur" dx="0" dy="0" result="offsetBlur">
<feOffset dx="1" dy="1" result="offsetblur">
```

```HTML
<feFlood flood-color="red" result="offsetColor">
```

Finally, we create a duplicate of the popper with the `<use>` element, and apply our filter.

```HTML
<use xlink:href="#popper" filter="url(#glow-red)">
```

---

Here's what we have so far:

```HTML
<svg viewBox="0 0 125 120">
    <defs>
      <filter id="glow-red" height="122%">
        <feGaussianBlur in="SourceAlpha" stdDeviation="5"></feGaussianBlur> 
        <feOffset in="blur" dx="0" dy="0" result="offsetBlur"></feOffset>
        <feOffset dx="1" dy="1" result="offsetblur"></feOffset>
        <feFlood flood-color="red" flood-opacity="1" result="offsetColor"></feFlood>
        <feComposite in="offsetColor" in2="offsetBlur" operator="in" result="offsetBlur"></feComposite>
      </filter>
    </defs>
    <use xlink:href="#popper" filter="url(#glow-red)"></use>
    <path d="..." id="popper" class="popper"></path>
</svg>
```

---

Now we have our glow. But what if we wanted it to flicker, like an actual neon sign?

We can do that using CSS animations:

{% codepen https://codepen.io/barhatsor/pen/ExNVGqK default-tab=result %}

Here, we're making each popper appear at a certain time in the animation.

The first popper appears at 1/3 of the animation (33%), the second popper appears at 2/3, and so on.

Here's how you would write that in CSS:
```CSS
@keyframes first-popper-appear {
  0%, 33.33% {
    opacity: 1;
  }
  33.99%, to {
    opacity: .1;
  }
}

/* And so on... */
```

---

**End result:**
{% codepen https://codepen.io/barhatsor/pen/vYXdVEj default-tab=result %}

Thanks for reading!
Dynamic Software Development Method (DSDM) in SDLC, DSDM Phases, DSDM Techniques.
Tags: beginners, testing, devops, tutorial
Published: 2021-02-04 07:53:58

What is the **Dynamic Software Development Method(DSDM)**?

DSDM is an approach to software development for Rapid Application Development (**RAD**) which **offers an agile platform for project delivery**. The key feature of DSDM is that users need to be actively involved, and **the decision-making power is provided to the teams**.

*DSDM Phase-*

**Pre-Project Phase:**
You make sure the projects are **set up based on a specific target** during the Pre-Project process. To begin the feasibility stage of the project, **you must ensure that resources exist**.

**Feasibility Phase:**
You want to make sure projects are technologically feasible and cost-effective during the feasibility process. You do only enough to **decide whether the priorities of the company are appropriate for further preparation**.

**Foundations Phase:**
The aim here is **to get a picture of the project's scope of work** and place the basis for identifying it and estimating the completion of items within the project, **using range estimates if appropriate**.

![Random 3](https://dev-to-uploads.s3.amazonaws.com/i/9zya0w8rfmj1hob2r2j9.png)
 

**Evolutionary Development Phase:**
To control the iterations, Evolutionary Creation makes **use of timeboxing**, with **each iteration releasing a completed piece of a much larger whole**.

**Deployment Phase:**
In many cases, you can either **deploy the entire solution**, which might make sense, or **with each loop, you can deploy small parts of the solution through an iteration of evolutionary growth**.

**Post-Project Phase:**
Your project is complete and you reach the Post-Project Phase **when all of your prototypes are complete** and you have a solution or product completely created.

*DSDM techniques-*

**Flexibility**: The flexibility of the criteria to be **achieved has a direct effect on the processes and controls of implementation** and on system acceptance.
It assumes that **80% of the proposed system can be generated in 20% of the time** it would take to create the entire system, which is useful and useful.

**80:20 Model**: A basic principle is that nothing is constructed completely for the first time, but **that 80% of the proposed method can be generated in 20% of the time** it would take to create the complete solution in a functional and useful way.

**Time Boxing**: In addition to the activities that **lead to its execution**, Timeboxing operates by **focusing on when a business target will be reached.**

**MoSCoW Rules:**
*Must have* – fundamental to project success.
*Should have* – important but the project does not rely on.
*Could have* – left out without impacting on project. 
*Want to have but Won't have this* time for those valuable requirements that can wait till later development takes place.
Import Default From Named Export
Tags: javascript, webdev, modules
Published: 2021-02-04 07:48:02

---
title: Import Default From Named Export
published: true
tags: ['javascript', 'webdev', 'modules']
canonical_url: https://chan.dev/posts/import-default-from-named-export/
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/0zo5r2clwl545gmf0w2n.jpg
---

Importing `default` can be nuanced. There are just so many ways to do it.

I like to think of `default` as a named export with a fixed (non-customizeable) name.

Check out how we can import `default` like a named export.

```js
import { default as Highlander } from "./highlander.js";
```

The lines below yield identical results.

```diff
- import Highlander from "./highlander.js";
+ import { default as Highlander } from "./highlander.js";
```

Unlike named exports, you can't import `default` and use it directly. It **must** be remaned at import. This is why the more ergonomic option of `import MyAlias from "…";` exists.

## Use default thru a module alias [#](#use-default-thru-a-module-alias)

We've discussed [module aliases in past posts](https://chan.dev/posts/import-all-named-exports-into-one-variable/). And they have some overlap with the `default` export.

Check out this totally valid use of Module aliases and `default`.

```js
import * as Highlander from "./highlander.js";

Highlander.default();
```

Technically, you're not using the `default` keyward because we're accessing the reference as a property.

Of course, this looks a little strange when used in frameworks like React.

```jsx
<Highlander.default>…<Highlander.default />
```

## My take [#](#my-take)

I don't use `default as` or `ModuleAlias.default()` import styles in practice. I just find it helpful to remember how `default` is exported from modules.

In future posts, we'll cover two, more ergonomic alternatives capturing both default and named exports.

## Go pro [#](#go-pro)

This is part of a course I'm creating on modules at [lunch.dev](https://www.lunch.dev/).  
When live, members get access to this and other courses on React.

<script src="https://cdn.podia.com/embeds.js" async="async"></script>[Join lunch.dev for videos](https://www.lunch.dev/member)
How to explain JavaScript Closure to a 5 years old kid
Tags: javascript, react, node, typescript
Published: 2021-02-04 07:36:40

Lazy to read. Show me the code.
```javascript
// 👶 How to explain closure to a 5 years old kid
 
/** 
* Closure is like a candy factory
* You send the factory an order to make candies for you with your favorite flavor.
* The factory will pick the right expert for you,
* And it send back to you an expert's contact.
* Now whenever you need, you just call and submit the quantity.
* That expert will take care all the rest for you.
*/
const candyFactory = (flavor) => {
  const experts = {
    Chocolate: {
        name: 'Tim',
        secretRecipe: '🍫',
    },
    Strawberry: {
        name: 'Alex',
        secretRecipe: '🍓',		
    }
  }
  const expertByFlavor = experts[flavor];
  return (quantity) => {
  	return `${quantity} ${flavor} candies are made 
                by ${expertByFlavor.name}.`; 
  }
}

// The factory doesn't want to send you their experts,
// Because it may leak their top secret recipe. 
// Instead, they just send you a way to call the expert (as a function) 
// and waiting for your calling to order anytime.
// Now the factory keeps your flavor and your expert.
// In conclusion:
// Only the inner function can access outer function'scope.
// Only the factory can directly tell the expert what to do.
const chocolateExpert = candyFactory('Chocolate');
const stawberryExpert = candyFactory('Strawberry');
                              
console.log(chocolateExpert(1000)); 
// 1000 Chocolate candies are made by Tim.
console.log(stawberryExpert(500));
// 500 Strawberry candies are made by Alex.
```

Try it at [JSFiddle](https://jsfiddle.net/4mkbyu2d/)
Digging in to Objects and Classes in Ruby
Tags: devjournal, codenewbie, womenintech
Published: 2021-02-04 07:28:06

_This post was originally published on February 4, 2021 on [my blog] (https://alexlsalt.github.io/blog)._

-------------

Hello! Yesterday, I made my way super slowly through doing a deep dive into learning about classes and objects in Ruby.

(I typically spend a couple mornings each week working through a course on Ruby.)

Thankfully, I now consider myself to be pretty good at understanding when I should go more slowly and opt for a deeper understanding of a topic (i.e. it’ll be worth it to spend more time on it now than breezing through it), and this was one of those situations.

It definitely helps, too, that I’ve been able to recognize much of what’s going on in since 1) I’ve seen instances of it (more advanced) in the codebase at work, and 2) I'm able to make the connections from having already learned JavaScript.

I try to spend an hour and a half or so on the course at least three times each week, and yesterday's session was seriously just *one little section* of that particular chapter.

And I’m not mad about it at all! Because I can honestly say I have a fuller understanding of it than I did before. Onward!

-------------

Pssst! I send weekly newsletters about the self-taught coding journey and my own coding adventures (and misadventures!)  [Sign up here! >>](https://ladies-code-collective.ck.page/e53b5fca44)
Teeny.go server with CLI mode
Tags: go
Published: 2021-02-04 07:21:42

As I said in https://dev.to/brcontainer/teeny-go-a-route-system-for-go-golang-2o10, Teeny.go (or teenygo or only teeny) is a micro-module for create a micro-webserver with support for routes and routes with patterns similar to PHP and JavaScript web-frameworks

For install use

```
go get -u github.com/inphinit/teeny.go
```

For create a application with support for command line arguments you can create manualy using `os.Args` or using `app.CliMode()`, example:

``` golang
package main

import (
    "fmt"
    "net/http"
    "github.com/inphinit/teenygo"
)

func main() {
    //Default host and port
    app := teeny.Serve("localhost", 7000)

    app.Action("GET", "/", func (response http.ResponseWriter, request *http.Request) {
        fmt.Fprint(response, "Homepage")
    })

    app.Action("GET", "/about", func (response http.ResponseWriter, request *http.Request) {
        fmt.Fprint(response, "About page")
    })

    app.HandlerCodes([]int {403, 404, 405}, func (response http.ResponseWriter, request *http.Request, code int) {
        fmt.Fprintf(response, "Error: %d", code)
    })

    app.CliMode()
}
```

For build:

```
go build program.go
```

Usage example:

```
program.exe --debug --host 0.0.0.0 --port 8080 --public "/home/foo/bar/assets"
```

### CLI mode arguments

Argument | Example | Description
--- | --- | ---
`--tls` | `program --tls` | Enable TLS mode in your program (use with `--cert` and `--key` if it is not pre-configured)
`--tls` | `program --no-tls` | Disable TLS (if in the initial configuration of the script it was enabled)
`--debug` | `program --debug` | Enable debug mode in your program
`--debug` | `program --no-debug` | Disable debug (if in the initial configuration of the script it was enabled)
`--fcgi` | `program --fcgi` | Enable Fast-CGI mode in your program
`--fcgi` | `program --no-fcgi` | Disable Fast-CGI (if in the initial configuration of the script it was enabled)
`--cert` | `program --cert /home/foo/cert.pem` | Define certificate file (use with `--tls` if it is not pre-configured)
`--key` | `program --key /home/foo/key.pem` | Define key file (use with `--tls` if it is not pre-configured)
`--public` | `program --public /home/foo/assets` | Define folder for access static files
`--host` | `program --host 0.0.0.0` | Define host address
`--port` | `program --port 9000` | Define port addres
Google Sheets in Sync with DronaHQ Studio Sheets using Zapier
Tags: dronahq, zapier, googlesheets, integrations
Published: 2021-02-04 07:18:03

Hi!

I have published an article about "Google Sheets in Sync with DronaHQ Studio Sheets using Zapier" on Medium.

Please feel free to check it out and let me know what you think about it.

[Read Here](https://ambar-04.medium.com/google-sheets-in-sync-with-dronahq-studio-sheets-using-zapier-b36d3fcb7fd3)

Thank you so much for your attention and participation.
Using DronaHQ in Zapier
Tags: dronahq, integrations, lowcode, automation
Published: 2021-02-04 07:05:28

Hey,
I have published an article about "Using DronaHQ in Zapier" on Medium. 
Please check it out and let me know what you think about it.

[Read Here] (https://ambar-04.medium.com/using-dronahq-in-zapier-859c477db151)