teleren/devto huggingface dataset:
00: Pure mathematics and JavaScript 
Tags: html, css, javascript, webdev
Published: 2020-04-11 08:50:42

#I love Pure mathematics,
I love actualizing my imagination, so I chose front-end engineering.
It is a good combination with User Interface Design, User Experience, Functional Programming, Visual projects, deep inside there are beautiful pure mathematics, 

*MATH is a true human discovery, Love must win* 

---

##Javascript is my hope

JavaScript covers from frontend development to backend and I want to start over from vanilla JS by building the small projects, Js is between UI/UX Design and Computer Science, **THE BALANCE** 

I am not familiar with solving algorithm problems, I would prefer to build the artwork project, such as making card news, navigation bar, landing page, etc... 

My goal is to learn in reverse from building the projects to Data Structure and Algorithms. That is how I decided to learn front end engineering, and want to focus on making structures using Vanilla JS efficiently, Follow, my instincts. 



--- 
##Project-driven Learning 

The purpose of learning all the computer language is developing something, it can be whatever I want to try, Let me find the things I would like to develop for myself, and creating my frontend engineering world. :) 
 
[The key is here] (https://blog.openclassrooms.com/en/2017/04/13/project-driven-learning-the-key-to-your-success/)
Compile Podcast Ep 12: How to avoid quarantine gut?
Tags: podcast, health, dieting
Published: 2020-04-11 08:43:26

This week my friend Yuekun and I talk more about maintaining a healthy diet during the quarantine, and how to avoid getting a quarantine gut!

{% youtube RMd6FwndylE %}

### Breakpoints

 - 00:32 Chill zone and catching up
 - 07:26 Topic intro: how to avoid quarantine gut
 - 12:50 A balanced diet
 - 16:50 "Eat your vegetables"
 - 19:30 Yuekun recommends a few staple vegetables 
 - 38:38 How to correctly limit total caloric intake
 - 44:45 Enjoy your food
 - 47:41 Counting calories work, but don’t count on it
 - 53:46 Consider using supplements
 - 57:58 Wrapping up

### Links in this episode:
 
 - Great [video](https://www.youtube.com/watch?v=BtulL3oArQw) from Vietnam about Covid-19
 - Yuekun's [Instagram](https://www.instagram.com/that_chinese_guy_)

### Reach out to us!

Subscribe and stay tuned! Also send in any comment or request for new topics and we will try our best to make them happen!

My Twitter: https://twitter.com/WujunaoNick

This Podcast is also on:
 - [Google Play Music](https://play.google.com/music/listen#/ps/Ifd5mlxhgc5cmlsytadsglqfd4y)
 - [iTunes](https://podcasts.apple.com/gb/podcast/the-compile-podcast/id1436437367)
 - [Spotify](https://open.spotify.com/show/2UH9hK7VlS7ytjYdM8Vd78)
Dependency Inversion Principle
Tags: codequality, javascript, oop
Published: 2020-04-11 08:37:05

The Dependency Inversion Principle is a component of The [SOLID Principles](https://dev.to/acroynon/the-solid-principles-15a5). These principles set out simple rules to follow that allow us to create maintainable and easily extensible codebases. The dependency inversion principle states that any entity should depend on abstractions rather than concrete implementations. This basically means that when you have one class that is dependent on another class it should use polymorphism to depend on an abstracted interface rather than the concrete implementation of the class. This allows you to easily swap out concrete implementations without having to refactor all dependent classes.

The below code snippet shows an interface called 'UserRepository'. We are going to use this interface to create subclasses that handle users in our database. This is a common approach as it allows you to create multiple child classes for different databases or storage mediums. For example, we could have one child for a SQL database and another for an in-memory database.

```java
public interface UserRepository {

  User findUserById(long id);
  boolean createUser(User user);
  boolean deleteUserById(long id);

}
```

Below we are defining a class called 'UserRepositoryImpl' which implements our interface. I haven't added all the code for the class, as we don't need to see that to understand the dependency inversion principle. So far we have an interface to define our operations and a concrete class for our user repository.

```java
public class UserRepositoryImpl implements UserRepository {
  // Implement methods
}
```

Now we create a class that interacts with our repository. This class takes our user repository as a parameter in its constructor. As you can see it is using polymorphism to depend on the interface rather than the concrete class. This allows us to replace the implementation (or concrete class) without having to modify the dependency of our UserController class.

```java
public class UserController {

  private UserRepository repository;

  public UserController(UserRepository repository){
    this.repository = repository;
  }

  // More processing and operations

}
```

This is the basis of the dependency inversion principle. Our class is dependent on an interface rather than a concrete class. However, it is important to note that you do not need to, and shouldn't, use this technique on every class in your codebase. Sometimes it doesn't make sense to use dependency inversion. If our implementation is not ever going to change then using the dependency inversion principle is pointless, as we will never have to switch out the implementation. If we are likely to change the implementation, such as changing the database implementation from SQL to in-memory, then it makes sense to use a dependency inversion approach.

This post was originally published on https://acroynon.com
Interface Segregation Principle
Tags: codequality, javascript, oop
Published: 2020-04-11 08:36:59

The Interface Segregation Principle is a component of The [SOLID Principles](https://dev.to/acroynon/the-solid-principles-15a5). The SOLID principles are useful tips and rules to follow when writing software and code to create a maintainable and easily extensible codebase. The interface segregation principle states that any object or class should not be forced to override or implement any method that it does not use or any method that doesn't make sense for its context and purpose.

The below code snippet shows a simple interface called Bird. This interface has two abstract methods, 'walk', and 'fly'. When we implement, or inherit, from this interface we will be forced to override and provide a body to both of these methods. According to the interface segregation principle, we shouldn't implement this interface if it doesn't make sense for the object to override both of these methods.

```java
public interface Bird {

  void walk();
  void fly();

}
```

Now let's create a subclass from our Bird class. The below class called Pigeon inherits from the Bird class. This means we need to override and implement both the 'walk' and 'fly' methods. This is fine and this makes sense, pigeons can both walk and fly. This doesn't break the interface segregation principle as it makes sense for a pigeon class to implement these two methods, we haven't forced any unexpected or unneeded functionality.

```java
public Pigeon implements Bird {

  @Override
  public void walk(){
    //TODO
  }

  @Override
  public void fly(){
    //TODO
  }

}
```

Let's look at another example. The below class creates a Dodo class that inherits from the Bird class. This is where we are breaking the interface segregation principle. If you didn't know, a Dodo bird cannot fly. This means, by inheriting from the bird class, we are forcing our Dodo class to implement a method that is doesn't need and that it doesn't make sense for it to have. Often times in large codebases inheritance is used to avoid duplicating code and when the interface segregation principle is broken the method is simply given a '//noop' comment. This stands for 'no operation'. Never use a '//noop' comment.

```java
public Dodo implements Bird {

  @Override
  public void walk(){
    //TODO
  }

  @Override
  public void fly(){
    // noop
  }

}
```

Instead of using a bird class we can create an interface called 'CanFly', as shown below. This will allow us to inherit this interface on only the classes where it makes sense, and we would also be able to use it on classes that aren't types of birds without confusing our inheritance tree. This is a more abstract way of thinking about objects and classes as we are not assigning names to nouns that exist in the real world (e.g. bird, dodo, pigeon). This is often the reason why beginner developers break the interface segregation principle.

```java
public interface CanFly {

  void fly();

}
```

This post was originally published on https://acroynon.com
Liskov Substitution Principle
Tags: codequality, javascript, oop
Published: 2020-04-11 08:36:54

The Liskov Substitution Principle is a component of The [SOLID Principles](https://dev.to/acroynon/the-solid-principles-15a5) which helps you create maintainable and extensible code. This principle states that any class should be able to be substituted for any of its subclasses without any issues. This basically just means that if you have a parent class and a child class you should be able to use the child class in any place where the parent is used without your program blowing up in errors.

The below code snippets shows a very simple piece of code. First, a User object is created called 'john'. We pass the value "John" into the constructor of the class and then print out the value from the 'getName' method to the console. This basic example will effectively set the passed in value to a variable and then print out the variable to the console.

```java
public class Main {

  public static void main(String[] args){
    User john = new User("John");
    System.out.println(john.getName());
  }

}
```

The code below looks exactly the same to the above code snippet. The only difference here is that we have changed the concrete implementation class to "Person". Other than that the code should function exactly the same. We are assuming in this example that the Person class inherits from the User class, it is a child of the User class. This is a prime example of the Liskov Substitution Principle, the subclass can be used instead of the base class and the code still makes sense and still executes.

```java
public class Main {

  public static void main(String[] args){
    User john = new Person("John");
    System.out.println(john.getName());
  }

}
```

The Liskov Substitution Principle is a simple principle to understand and a simple concept to understand. It is important to understand that it is a one way track. Any subclass can replace any usage of its base class like shown above. However, the reverse is not true. You cannot replace a usage of a subclass with a base class. Usually, a subclass adds functionality or extends from a base class, therefore, replacing a usage of a subclass with a baseclass does not make sense as the base class does not have the added functionality.

This post was originally published on https://acroynon.com
How to change your default text editor for git (and avoid vim)
Tags: git, tutorial, beginners
Published: 2020-04-11 08:36:24

---
published: true
title: "How to change your default text editor for git (and avoid vim)"
cover_image: "https://raw.githubusercontent.com/biancapower/my-dev.to/master/blog-posts/how-to-change-your-default-text-editor/assets/cover1.png"
description: "How to change your default text editor for git (and avoid vim)"
tags: git, tutorial, beginners
series:
canonical_url:
---

We've all done it. `git add .` then... `git commit`. Big mistake. We forgot to add a `-m` with a message! Now we're in the dreaded vim text editor...

{% asciinema 318599 %}

_But what if there was another way?_ By changing the git config, we can specify **a different editor for git to launch us into** if it needs to do so. Below is how to do this on a unix (OSX or Linux) system.

First, **check what your current system default is** (you can pause the video below and copy the text command out of it - try it now!):

{% asciinema 318597 %}

In the example above, as on many systems, the default editor is vim. Personally, I love vim, but if you're not familiar with it it can make things a bit difficult and really mess up your flow. First let's look at **how to change git's default text editor to nano**, and what nano looks like in practice:

{% asciinema 318600 %}

As you can see, nano is much more straight forward than vim (not least because it gives you the commands you need at the bottom of the screen!), but it still exists completely in the terminal (which has pros and cons).

What if you want to change the editor used by git to something external to the terminal, like **VS Code**? Here's how:

{% youtube R9u2e66IKzc %}

Note that changing the editor to `code` didn't work quite as we wanted it to - because we're leaving the terminal environment in order to go and edit the file in VS Code, we need to tell git to wait for us. We do that by specifying `code --wait`, which basically says "Hey git, I'm gonna go over to VS Code to edit that file now, just hang about, and once I've closed that file you can read it and finish processing the command".

The process for changing the default to other text editor is basically the same, it's just a matter of finding the correct key word(s) for launching the editor.

What do you use as your default text editor? Comment below!

# Found a typo?

If you've found a typo, a sentence that could be improved or anything else that should be updated on this blog post, you can access it through a git repository and make a pull request. Instead of posting a comment, please go directly to https://github.com/biancapower/my-dev.to and open a new pull request with your changes.
vscode-slides
Tags: linting, javascript, presentation
Published: 2020-04-11 08:34:14

**note: This will be the second time I write this post. If this vanished in thin air, I'll just give up....**

I had a presentation last monday regarding linting this was to ensure the spread of knowledge of the causes and solutions to the problems they encounter. Also what linting is and why we do it.

So for that presentation I wanted to find a different presentation tool than powerpoint because if everything else can be expressed in code, why not a presentation? Just a short google away I found vscode-slides which seemed to fit my needs. I tried it out and it had two pain points.

It overwrote/didnt adhere to my settings in settings.json of the workspace. And sometimes it even overwrote the settings that existed there with it's own default ones.

I raised issues regarding these two things in the github project for the extension and for one of them I was referred to an old ticket that was similar, but not quite the same. However they also wanted to have a manner of changing/having custom settings that were not overwritten. So I started by forking the project and making changes to support the specified .slidesrc file that the author figured would solve it.

Long story short, I made a PR and the author was inspired to do additional changes and merge it with my PR and now there's a new version of the extension out! [Check it out](https://marketplace.visualstudio.com/items?itemName=nicoespeon.slides)
The Simplest Ways to Make the Best of Javascript Games Code
Tags: html, javascript, wevdev, beginners
Published: 2020-04-11 08:32:15

---
title: The Simplest Ways to Make the Best of Javascript Games Code
published: TRUE
description: 
tags: #html,#javascript,#wevdev,#beginners
---

<h1>check out More Example</h1> [<h1><b>GSCODE</b></h1>](https://gscode.in/best-of-javascript-games-code/)

<p>1.2048 game</p>

{% codepen https://codepen.io/camsong/pen/wcKrg %}


<p>2.Tower building game. Place blocks by clicking, tapping or spacebarring. </p>

{% codepen https://codepen.io/ste-vg/pen/ppLQNW %}


<p>Save this little guy from this (not so evil) wolf. It starts very slowly, but don't be fooled, you probably can't stand the speed.</p>

{% codepen https://codepen.io/Yakudoo/pen/YGxYZj %}


{% codepen https://codepen.io/MillerTime/pen/BexBbE %}

<h1>check out More Example</h1> [<h1><b>GSCODE</b></h1>](https://gscode.in/best-of-javascript-games-code/)
What's the biggest tech-stack change you've had?
Tags: discuss, python, csharp, career
Published: 2020-04-11 08:31:18

---
title: What's the biggest tech-stack change you've had?
published: true
description: I went from C# to Python and it's wild
tags: discuss,python,csharp,career
---

For the past few years, I've been using C# and ASP.NET professionally. I got used to the way it felt. I became comfortable with the tools and the libraries to use in each situation. I invested in the ecosystem to learn more and be better at my job.

A few months ago, I changed jobs. With a new job came a new tech-stack and it's wild. Today I'm using Python and maintaining a Django app. I haven't used Python since high school and I've never used it professionally until now. If you're familiar with both languages, you may know how different they are.

![Aladin and Jasmine, a whole new world](https://media.giphy.com/media/11thnyggFkrmmc/giphy.gif)

Python is a joy to read compared with C# code. There are things I miss and gaps in knowledge where Python has evolved over the years. It's new and exciting, I feel like the change has helped inspire me again and take me out of my comfort zone.

# What's the biggest tech-stack change in your career and what did you gain from it?
10 Automation Testing Tools That every QA Should Know.(With MindMap).
Tags: testing, career, beginners, tutorial
Published: 2020-04-11 08:20:44

Here is the List of top 10 Automation Testing tools 202 Edition, Automation Tester tools are must have tools for any SDET or QA to know to perform a Automation Testing.


[![10 Automation Testing Tools 2020 Edition](https://i.imgur.com/khCe8UP.jpg)](http://www.youtube.com/watch?v=CntxAXMZSu0 "10 Automation Testing Tools 2020 Edition")



In this video, I am going to explore the top 10 Automation Tools that you should learn as QA/SDET.

Automation testing is a Software testing technique to test and compare the actual outcome with the expected outcome. 

This can be achieved by writing test scripts or using any automation testing tool. 

Test automation is used to automate repetitive tasks and other testing tasks which are difficult to perform manually

-----------------------------------------------------
👪 Join our Community - http://bit.ly/learntesting2019
✅ Automation Tester Community - https://thetestingacademy.com
🐦Follow us on Twitter  - https://twitter.com/itstechmode
📖 Like us on Facebook - https://www.facebook.com/scrolltest
🎤 Listen to our Podcast - https://anchor.fm/thetestingacademy
------------------------------------------------------

--
Be sure to subscribe for more videos like this!

[![ TheTestingAcademy](https://dev-to-uploads.s3.amazonaws.com/i/r7vcy6wbvyjbk1y1uu0o.png
)](https://www.youtube.com/TheTestingAcademy?sub_confirmation=1 "TheTestingAcademy")
9 Methods to Get Financing for Your Startup
Tags: funding, startup, investment
Published: 2020-04-11 07:56:26



Bootstrapping
  It is suggested as the first funding option because by broadening out your personal savings and talents, you are tied to your company. Also, at a later stage, lenders recognize it as your merit. Yet, it is a great choice of funding only if the original requirement is small as well as handy.





Family and Friends
If you need supplementary funding for your firm, but you don’t have your credit cards or savings, then you can strengthen family and associates to fund in the firm with the impression that their money may not be reimbursed. If the firm wins, a gratuity to these risk-takers would be a great signal.





Customers
Generate early profit from consumers to cover some of the development costs in exchange for limited first access or discount.





Angel Investor
Angel lenders are bodies with excess money who have keen significance to spend in upcoming firms. They also give coaching or advice beside money.





Crowdfunding
It is the pooling of proficiencies by a group of people for a common purpose. Crowdfunding is not innovative to India. There are various illustrations of organizations attaining out to various people for funding.





Start – up Incubators
Join a startup incubator support or accelerator programme where you will have access to seed funding for startups in India, company support,  mentors, network and follow financing.





Business Grants
Apply for grants. May desire a stringent due system and time but you won’t have to give up any equity.





Venture Capital
There are experienced regulated funds which are invested in firms that have great power. Venture capitalists grant expertise,coaching and accomplish as a litmus test of where a firm organization is going, assessing firms from sustainability as well as scalability point of outlook.





Bank Loan
This drives best when you have a verified business model and validated methods of getting profit to pay back the loan.









Reference Link:- https://www.startuppaisa.com/blog/9-methods-to-get-financing-for-your-startup/
How has the Coronavirus been affecting you?
Tags: covid19, watercooler, health, mentalhealth
Published: 2020-04-11 07:37:06

How has this pandemic (emotionally or the virus itself) been affecting your daily routine and life? It's taken me a while to accept that my normal daily life has now been changed drastically for the foreseeable future, and it still scares me sometimes. I don't want to get too personal, but this last semester is very meaningful to me, and thinking about having the rest of it cancelled and moved online can hurt sometimes. However now I'm looking on the brighter side, which is all this free-time I have!

How has all of this personally affected you?
Import npm modules to AWS lambda function
Tags: aws, npm, node, lambda
Published: 2020-09-20 16:07:14

---
title: Import npm modules to AWS lambda function
published: true
date: 2020-04-11 07:26:19 UTC
tags: aws,npm,node,lambda
canonical_url: https://medium.com/@victorleungtw/import-npm-modules-to-aws-lambda-function-32e2efd7e30d
---

When you create a node.js lambda function on Amazon Web Service (AWS), and start editing using the online editor, then you want to **npm install** and import a third party library, such as **lodash** , unfortunately there is no simple way to do it via the web portal.

In order to do so, you need to write your code in local environment and deploy it. First, create a folder in your machine and copy the index.js file inside it. Then run the below command to init and install your dependency:

```
npm init . 
npm install lodash --save
```

Import your libary to the index.js, such as

```
let \_ = require('lodash');
```

After you finish writing your code, zip the entire folder including those **node\_modules** via this command:

```
zip -r function.zip .
```

Finally, deploy the zip file using AWS CLI tools in terminal:

```
aws lambda update-function-code --function-name yourFunctionName --zip-file fileb://function.zip
```

Replace yourFunctionName placeholder with your function name. If it’s deploy is ok, you should see “LastUpdateStatus”: “Successful” and you can continue the testing in the console.

_Originally published at_ [_https://victorleungtw.com_](https://victorleungtw.com/2020/04/11/import-npm-modules-to-aws-lambda-function/)_._
Food Delivery Boy App Design - Part 2/2
Tags: ionic, firebase
Published: 2020-04-11 06:45:46

Hello Everyone!

I have created my food delivery boy with Ionic and Firebase. I'm sharing my app designs here. please share your feedback

---

- User App: https://dev.to/mythemebox/food-delivery-app-design-user-app-part-1-4cnf
- Driver App: https://dev.to/mythemebox/food-delivery-boy-app-design-part-2-2-18go

---

Credits: https://mythemebox.com/template/ionic-food-delivery-single/

## Driver App Design

![](https://github.com/codesundar/ionic-firebase-food-delivery/raw/master/screenshots/driver-app-ui.png)