teleren/devto huggingface dataset:
The First Open Source Contributor Summit
Tags: contributorswanted, opensource, hacktoberfest, javascript
Published: 2020-09-28 03:59:03

Contributing to open source can be challenging, especially when the first step for getting involved is unclear. 

## What is a contributor summit?

In partnership with Swimm, the Open Sauced community will hold a free and unique event focused on educating attendees about becoming contributors to open-source projects. The goal for this event is to bring the community together to get any context missing from the CONTRIBUTING.md files.

Learn directly from the maintainers of projects ways you can contribute during Hacktoberfest.

## When is this happening?
This event kicks off with talks from maintainers and experts in the open-source on October 15th. It continues asynchronously via our [community discord](https://discord.com/invite/gZMKK5q) with workshops, Q&A, and discussions focused on getting folks involved in open source projects.

If this sounds like the event for you, [RSVP on our Meetup page](https://www.meetup.com/Open-Sauced-Meetup/events/273235053/) and come ready to learn. 

## Some of the projects represented during the event.

{% github no-readme https://github.com/pikapkg/snowpack %}

{% github no-readme https://github.com/supabase/supabase %}

{% github no-readme https://github.com/hoppscotch/hoppscotch %}

{% github https://github.com/guardicore/monkey %}

[RSVP to the meetup](https://www.meetup.com/Open-Sauced-Meetup/events/273235053/) for event updates.
Singapore Geospatial Week+ 2020 Summit Review
Published: 2020-09-28 03:21:57

Last week, Singapore Geospatial Week+ 2020 is successfully held. More than 300  business leaders and developers from top real estate, retail, and e-commerce  developers join this online event.

The Singapore Geospatial Week is held annually by the Government of Singapore Land Authority and brings together industry participants and the public. The event is led by Singapore Mobile Ecosystem Development BD Goh Cheng Wee and partners to organize a series of activities to explore the potential of industry technologies and promote in-depth cooperation among various industries on Huawei mobile services.

During the morning tech forum event entitled "Unlocking Countless Potential in Real Estate", Liusihao from HMS Core Product Dept, participated in the technical panel entitled "How to use technology innovation to serve the retail and real estate industries" with technical experts from CapitaLand, PTGEM, etc.. He shared HMS Core refined analytics operation service, indoor and outdoor location service and AI technologies, helping developers in application innovation. The online developers discussed and expressed full interest in these service kits.

At a special session on the afternoon of the same day, released HMS Core lifestyle and e-commerce solutions for Asia-Pacific Region. Li Mingnan(Nando), lifestyle industry owner of the HMS Core Product Dept, discussed technical solutions and application scenarios with more than 100 online developers, and answered their questions. Then showed how HMS Core opens network, 5G, and AI technologies to bring brand-new experience to lifestyle applications, as well as the actual scenarios of indoor location and Super GNSS.

This activity explored new cooperation models with partners and established long-term dialogues, which are expected to further force the go-onboard and integration of regional applications and also improve the influence of the HMS ecosystem in the industry in the region. Next, we will provide product and  technical support for developers.
Strategy Pattern
Tags: behavioral, pattern, designpatterns, java
Published: 2020-09-28 03:58:36

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/702xd1hb05y2kbdpcfgo.png)

#Participants#
* Strategy: declares an interface common to all supported algorithms. Context uses this interface to call the algorithm defined by a ConcreteStrategy
* ConcreteStrategy: implements the algorithm using the Strategy interface
* Context: is configured with a ConcreteStrategy object. Maintains a reference to a Strategy object. May define an interface that lets Strategy access its data.

#Code#
```java
public class Main {

	public static void main(String[] args) {
		Context context;
		context = new Context(new ConcreteStrategyA());
		context.contextInterface();
		context = new Context(new ConcreteStrategyB());
		context.contextInterface();
	}
}

public interface Strategy {

	void algorithmInterface();

}

public class ConcreteStrategyA implements Strategy {

	@Override
	public void algorithmInterface() {
		System.out.println("Called ConcreteStrategyA.AlgorithmInterface()");
	}

}

public class ConcreteStrategyB implements Strategy {

	@Override
	public void algorithmInterface() {
		System.out.println("Called ConcreteStrategyB.AlgorithmInterface()");
	}

}

public class Context {
	private Strategy strategy;

	public Context(Strategy strategy) {
		this.strategy = strategy;
	}

	public void contextInterface()	{
		strategy.algorithmInterface();
	}
}

```

#Output#
```
Called ConcreteStrategyA.AlgorithmInterface()
Called ConcreteStrategyB.AlgorithmInterface()
```
{% github https://github.com/eidherjulian61/design-patterns no-readme %}
{% link https://dev.to/eidher/principales-patrones-de-diseno-13ao
 %}
Database Normalization 
Published: 2020-09-28 03:51:19

Today I will be going over Database Normalization and how that will work for the database I have beastmodecap_covid. 

Here is an example of what one of the three things that I will be talking about. This one in particular is failing the third part of the first database normalization category. 

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

I will be talking about the first two database normalization models. There is a total of five and the sixth is not standardized. 

All of the rules for the first database normalization goes as such:

1. Each primary key needs to be unique.

2. Each table cell should contain a single value. 

3. There can be no duplicating groups. 

The second database normalization needs to be the first database normalization. 
The two rules for the second database normalization are as follows: 

1. Be in the first database normalization

2. Single Column Primary Key

Here is an example of the second database normalization: 

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

This fails because of the JobRisk is not related to the behaviors you have in the day. 

Here is the youtube video of me talking about database normalization:  https://www.youtube.com/watch?v=AzDduP1GZhk&ab_channel=BeastMode
Movie Central App
Published: 2020-09-28 03:40:23

For my fifth project at the Flatiron School, I made a web application using the very popular JavaScript framework React & also the handy framework Redux. Growing up I was never really into watching movies and I became somewhat known to not keep up with all the popular movies and as someone who didn’t watch movies that are considered “classic movies”. Hoping to increase my knowledge of movie references and be more in the know, I wanted to create an app that will be helpful to me and to others in seeing what movies were currently popular and also the movies that are rated very highly.

To create this project I used React & Redux for the frontend of my application and Ruby on Rails as an api for the backend of my application. With React I was able to build components that I can reuse at will to build out the client side. With the help of Redux and redux thunk, I was able to asynchronously send fetch requests to the Rails api I built.

I decided that this application will allow users to browse through popular movies and top rated movies. I also inculded the option of adding a specific movie to a watchlist specific to every user, but this function is only open to users who register and is logged in to their account. I made this decision with the notion that while logging into and account to save movies to a watchlist is a great feature, I did not want an authentication wall to block people from browsing through movies.

I also used The Movie Database API as an external api to get the info I wanted on all the movies. I made the choice to make the get requests from the rails api I built and then send the necessary info to the front end of my application when a GET request would come in from the user. Although there was the possibility of just building out the frontend and letting it communicate with the TMDB API directly, I felt that it would be better to have the info centralized in my Rails API as was also using it as a way to persist user account information including the movies that a user saves into their watchlist.

With all of the HTML requests being made from the frontend, I used Redux to have a central store to organize state better in my React frontend. I still made use of passing in props but the redux store definitely helped in organizing state as I built this application.

All in all, I was able to experience first-hand the power of React & also Redux. It is no wonder why React is so popular today, and I am looking forward to making a React application in the future using Hooks to experience another way to control state.
How to Tame messy NPM scripts in 5 minutes
Tags: node, javascript, bash, productivity
Published: 2020-09-28 03:34:06

Problem? Sure, let's describe it, npm scripts are powerful, but in the case where you don't have a task runner and just want to keep it simple, you might opt to use npm scripts to achieve most everything with cli tools, bash and node scripts.

But sooner or later you realize that your scripts have become anything but simple. I'm here to tell you about a 🔥 hot new thing that isn't really new and it's been *hidden in npm docs* all along, it will help you move the complexity out of your npm scripts and into something you can reason about and maintain.

I have created a pattern (no downloads required) which I coin the *ops pattern*, so named because A, I couldn't think of a name and B, if you ask yourself what does it do, operations is probably a good description.

## The code
>package.json (simplified)
``` json
{
    ...
    "config" : { "heads" : 7 },
    "scripts": {
        "compile_the_jabberwocky": "./ops.js",
        "minify_the_hydra": "./ops.js"
    }
}
```
> "Adam, you fool, this is going to run the same script!"

Mmm yes but hear me out, you still want all your scripts in the same place, I promise I will show you the JavaScript in a moment, all will become clear, but let's cover the rules of the pattern first.
- one script
- use train case for script names because npm uses this for it's variable interpolation, it's the closest thing we have to an official standard... You know what they say, when in rome, don't invent a competing standard.
- no arguments, prefer "config" and `process.env`

> ops.js
``` js
const lifecycle = process.env.npm_lifecycle_event;
const scripts = {
    /*
    * @description such docs!
    * @note normally you can't comment
    */
    "compile_the_jabberwocky"() {
        //... Maybe exec bash or write some js or something else.
        // How about concurrently spawn or handle sync tasks
     },
     /*
     * @description proves you only need the key to match
     */
     "minify_the_hydra"() {
         // Get some params
         const silly_var = process.env.npm_package_heads
        exec('npx run_hydra');
     }
}

if (lifecycle in scripts) {
    scripts[lifecycle]();
}
```
### Closing thoughts
So long as the script name key in the package.json matches the function name, this will work, since all you want to do is to get npm to run some scripts, why not skip that and get JavaScript to run some scripts.

### 💡 Where did I get the idea from?
"Lastly, the npm_lifecycle_event environment variable is set to whichever stage of the cycle is being executed. **So, you could have a single script used for different parts of the process which switches based on what’s currently happening.**"

I stole it from the docs 😳, so next time you think, I need a task runner, do you really though?
I built a VSCode extension: Folder Size
Tags: vscode, typescript, extension
Published: 2020-09-28 02:40:01

---
title: I built a VSCode extension: Folder Size
published: true
description: 📁 Shows the current file | folder size in the status bar for Visual Studio Code
tags: vscode, typescript, extension
//cover_image: https://direct_url_to_image.jpg
---

At the beginning of this year, I planned a task on to-do, which was to develop a VSCode extension for the purpose of solving my own needs.


Recently, I have a small idea, I wanted counting the size of a file or folder without leaving the VSCode editor.


However, there is no such extension in the VSCode Extension Market.


So I began to build wheels

---

## Install

You can Install the extension in the website [Folder Size](https://marketplace.visualstudio.com/items?itemName=xiaoluoboding.vscode-folder-size)

or

Search "Folder Size" in Extension Market.

![install](https://cdn.jsdelivr.net/gh/xiaoluoboding/image-hub@latest/images/2020/09/202009_folder-size-install.png)

## Preview

![](https://cdn.jsdelivr.net/gh/xiaoluoboding/image-hub@latest/images/2020/09/202009_folder-size-preview.jpg)

## Features

Currently, Folder Size has two statistical functions are supported


### Count the [file | folder] size

When you selected/opened/saved file, extension will show the status of [📃 file | 📁 folder] size in the status bar.


### Show Number of statistical files

Click on the status bar to display the number of files and statistics in the folder where the selected file is located

---

👏 Welcome to try it.
Database Normalization
Published: 2020-09-28 02:39:08

Hello everyone, in this blog I will be going over Database Normalization.

Normalization is used in databases to reduce redundancies and overall simplify the information being stored to only the data you need which is stored only where its needed.

When addressing normal form there are 6 forms to look out for, but in this post we will just be going over the first two, 1NF and 2NF. (anything after 3NF is rarely if ever used anyways)

1NF is the first and base level of normalization forms. Each form builds off the one before it. This means that, for instance, 2NF must have all the same qualities that 1NF has plus more. 

For an example I will use my behavior table.
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/01rcb6u3jjmd22wbvujs.png)

In order for this database to be 1NF it must pass all three of these properties:
1. The data must be stored in tables with rows uniquely identified by a primary key
2. Data within each table must be stored in individual columns in reduced form
3. There can not be any repeating groups

The table above fits all these requirements as all of the data is reduced, unique, and under a primary key. 

Next we take a look at the 2nd normal form. 
Here we have to make sure that everything from 1NF applies as well as now making sure that only data that relates to the table's primary key is included in the table. 
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/saowr7sf7r5vvmw03n6p.png)
Here we see a table where all of 1NF applies, but there is an error with 2NF. LevOfProcedure does not fit in with the table's primary key. This variable applies to the occupation itself and not to the actual person doing the job like the other variables in the table. To remove this variable I used an alter command which is shown in the video.
https://drive.google.com/file/d/1gZyL4rqHi7QIADXklZ5bFW_fv2IrLOur/view
Thanks for reading.
Getting Started with Svelte JS
Tags: react, javascript, npm, svelte
Published: 2020-09-28 02:35:02

So I've been skimming through some Svelte documentation recently and from what I've been reading it seems to be earning my heart. The ease of use and implementation is all a developer can ask for. This short blog will mostly be about starting and setting up a Svelte application. For this I'll be using VSCode.

#What is Svelte?

"Svelte is a radical new approach to building user interfaces. Whereas traditional frameworks like React and Vue do the bulk of their work in the browser, Svelte shifts that work into a compile step that happens when you build your app.

Instead of using techniques like virtual DOM diffing, Svelte writes code that surgically updates the DOM when the state of your app changes."

- The website

##Step 1: 

Open VSCode and create the necessary folder where you will be housing your project.

##Step 2:

Go into your terminal and cd into that folder that you created.

##Step 3: 

Run the command

```> npx degit sveltejs/template app-name```

This will auto generate some files and folders for you. Similar to how React would.

##Step 4: 

After you run that command it will generate a folder with your app name. Cd into that folder then run 

```> npm install```

This will install all of the necessary dependencies. You should see a package-lock.json appear in your directory.

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


##Step 5:

Lastly, run the command...

```> npm run dev```

This will start a server running on PORT 5000 (http://localhost:5000). Happy coding!

======================================================

##Part 2: Building a Booklist Application using Svelte
Normality for a Flexible World
Tags: sql, database, normality
Published: 2020-09-28 02:30:39

It might be contradictory to view both normality and flexibility in the same vein, but we look to normality in database design to create flexible change. Besides, the idea of normality is a lot like nesting if statements. If you know what those are, anyway. If not, then here's a quick rundown of the first two normal forms:

First Normal Form:

We want to make sure that the data we present is necessary to have separately. For instance, look at this table.

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

First, let us ask if our table has a primary key.
Well, I wouldn't really get far without making one after the diagrams I've already shown, so yes, we have established "BehaviorID" as a primary key.

Are any columns able to be represented as two other columns?
I would say so. Instances can certainly arise in a messy setup, such as design a column to contain more than one piece of info, but most of the time, I would say you would recognize an issue like this immediately. Always make sure that a column is made to contain one type of data.

Then, finally, do any columns repeat their groups?
Not at all! We can safely establish this table as First Normal Form.

Second Normal Form:

To constitute a Second Normal Form, we need to keep all the components of First Normal in check. Then, we examine whether or not all columns refer to the primary key of the table. If anything could be representing something that isn't the primary key, it's likely that that data can be represented as a different entity (table) in the database.

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

Take this table for instance. As the OccupationName may relate to the CompanyID, all other columns can be related to the OccupationName, not the CompanyID. Thus, we must delegate that information into a new table by altering this one, then creating a new table to represent Occupations.

And yet, how will we do that? Watch the two videos below, and we'll get into how we ALTER tables in SQL, and have a live look at "Normality".

<a href="http://www.youtube.com/watch?feature=player_embedded&v=1bkNuNoucDo
" target="_blank"><img src="http://img.youtube.com/vi/1bkNuNoucDo/0.jpg" 
</a>

<a href="http://www.youtube.com/watch?feature=player_embedded&v=_wKy7mIeoW4
" target="_blank"><img src="http://img.youtube.com/vi/_wKy7mIeoW4/0.jpg" 
</a>
LED Blinking Program For Arduino UNO 
Published: 2020-09-28 02:22:15

#LED Blinking Program For Arduino UNO
Hello everyone, Now in this blog we are going to make LED Blinking Program for Arduino UNO, which is the basic project of the embedded system.
Let’s puts some LEDs and resistors to work. In this project, we will use one led and some resistor to make our project perfect (LED Blinking Arduino UNO).

##LED Blinking Arduino UNO Algorithm
Before starting to write the algorithm of the project first know what is an algorithm. Basically Algorithm is a step-by-step method, which specifies a series of instructions to be executed to get the desired output in a certain order. 

Algorithms are usually generated independently of the underlying languages, i.e. in more than one programming language, an algorithm may be implemented.

So, start writing the algorithm of our first project #1. Before going onto the algorithm part you should have a clear understanding of what is an Arduino UNO and basics parts.

Turn on the LED 1
Wait for a second
Turn off the LED 1
Repeat this process indefinitely
Required Components For LED Blinking Project In Arduino UNO
One led
A Resistor
One Bread Board
Wires
Arduino
USB Cables
##Arduino Code For LED Blinking
Here is the code for LED Blinking Program.
lED BLINKING
```
//initialize variables (for pin)
int ledPin = 11;

void setup()
{
  //set the pin mode to output 
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  	// send a HIGH(ON) signal to ledPin which is pin 11
    digitalWrite(ledPin, HIGH);
  	delay(1000);
   	digitalWrite(ledPin, LOW);
  	delay(1000);
}
```
In void setup() at the digital, I/O pins are set to outputs because we want them to send current to the LED on demand. We specify when to turn led using the digitalWrite() function in the void loop() section of the sketch.

##Use Variables
In a computer program, data is stored using variables. For instance, in Project (LED BLINKING ARDUINO UNO)   we used the delay(1000) feature to hold the LED Turns on.

For more click here ->(https://hackthedeveloper.com/led-blinking-arduino-uno/)