teleren/devto huggingface dataset:
Give your GitHub repository README.md some insightful eye-candy

Tags: opensource, github, news, motivation
Published: 2021-11-06 10:03:05

During a small hackathon we at [Axiom Inc.](axiom.co) we put together a small nifty tool.

The motivation behind it was to:

* Share interesting stats about your project activity, from code to issues.
* Let everyone see the top contributors, giving them well-deserved visibility.

We came up with **[Repobeats](repobeats.axiom.co)**.

Repobeats is a way to embed contributor analytics into your GitHub project's README.md
With Repobeats, contributors and users of your projects get a clear, beautiful, view of how your project is evolving over time.

**Why should I use Repobeats? you may ask!**

You should use Repobeats if you would like some deeper insights into how your project is evolving in regards to contributions and contributors.
Contributions evolve over time as projects mature, however it is often difficult to get the important details from GitHub directly. By presenting clear charts for issues, pull requests, and pushs/commits, Repobeats allows you to visually see changes in contributions over time.
This allows you to manage your project better and potentially entice new collaborators if they can see a clear way in which they could start helping the project.

***Repobeats is completely free. The service is maintained by [Axiom Inc.](axiom.co)***
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qeablml8zfbb7l1glh5c.png)

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cva91tljcufzsazerd0j.png)
Setup New SSH Key for GitHub
Tags: github, versioncontrol, git
Published: 2021-11-06 09:40:23

- Run Commands in GitBash

### Check for Exisiting SSH keys
```
ls -al /.ssh
```
Lists the files in your .ssh directory, if they exist

### Generate New SSH Key
```
1st : ssh-keygen -t rsa -b 4096 -C "<Enter Email Address>" and Hit Enter
2nd : Enter passpharse if needed (If not hit enter)
3rd : Repeat same passpharse
```

### Adding your SHH key to the ssh-agent
```
1st : eval $(ssh-agent -s)
2nd : ssh-add ~/.ssh/id_rsa
```

### Copy Key to Clipboard
```
clip < ~/.ssh/id_rsa.pub
```

### Setup SSH key in Github
1. Open [SSH Key Page](https://github.com/settings/keys) and Click on **New SSH Key**
2. Add Title to Nickname for the SSH Key (eg: Personal Laptop)
3. Paste Key from Clipboard
4. Click on **Add SSH Key**
Why write code
Tags: beginners, programming, career, challenge
Published: 2021-11-06 09:29:32

Chances are you've heard about programming in some form by now, I mean it would be pretty hard not to. From hackers in movies to those people making tons of cash in silicon valley.

If you are reading this maybe the title grabbed your attention or maybe you need a reason to take the leap. I wont lie to you its not an easy journey since I began its been an up hill battle. The learning never ends and the looming thought that you may be an idiot is ever present but there is a silver lining . 

The best and arguably worst part of writing code is the fact that you are constantly learning new incredible things and being challenged mentally, I promise the feeling after doing something that takes an abundant amount of effort feels way better than completing something that was easy. 

I recently began my journey this year. I decided to go with a coding bootcamp to give me a good structure to begin my learning adventure. My time in the program is almost over but I'll have new skills and techniques to learn for a lifetime. Writing code for me has been stressful, hard, I feel dumber everyday and it's scary imposter syndrome is very real. But all those things are why I love it, I'm always thinking about how can I get better and smarter if nothing is challenging me. I never just want to be content there is always something to strive towards.

So why write code, I honestly cant really say but if you enjoy problem solving, coffee, late nights,  the monetary benefits and the expanding scope of the profession. It is a very dynamic field there are a variety of jobs available and its adaptable to the many needs and demands of the market. Software engineers can become engineers in a wide variety of ways from bootcamps to college degrees or even the self taught route, each has there challenges but in the end you will discover an amazing community of incredible people who's intelligence and humor will make it all worth it.
What are SOLID Principles? Explained with OOP Concepts.
Tags: programming, softwaredevelopment, beginners, blog
Published: 2021-11-06 09:12:32

Software developers implement codes to meet the users’ requirements and satisfy the clients. Some principles have to follow by software developers to enhance their code writing skills.

The SOLID principles have considerable responsibility to guide the software developers, to make the software design by improving the code quality.

An American software engineer named Robert C.Martin created this principle.

Solid principles have five(5) principles. The name is created by considering the first five letters from each principle.

__The five principles are__,
S — Single Responsibility Principle
O — Open Closed Principle.
L — Liskov Substitution Principle.
I — Interface Segregation Principle.
D — Dependency Inversion Principle.

Let us have a look at each of the principles. Read more at https://praveena-thavarajah.blogspot.com/2021/11/what-are-solid-principles-oop-concepts.html.

Thanks for reading the blog. I hope you got to know about SOLID principles. For more posts follow me through my social media.
Introduction To Go Programming
Tags: go
Published: 2021-11-06 08:16:56

The Go programming language is an open source project to make programmers more productive. It is designed at Google by Robert Griesemer, Rob Pike and Ken Thompson. Go is syntactically similar to C, but with memory safety, garbage collection, structural typing and CSP-style concurrency.

Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. 

Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It's a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language.

#### Why did google build Go?

It is important to understand why google built Go. At the time of Go being built the most popular languages were Python, Java ,C & C++. However this languages had design limitations that would be difficult to patch, therefore Go was developed.

- **Python** - easy to use ,but slow
- **Java** - Complex Types
- **C & C++** - Fast but has Complex Types & Slow Compilation, at the time of their development machines weren't as powerful as today therefore they were built to work with little memory.

Also at the time of development of this languages, multithreaded systems were rare. 

#### Key Features Of GoLang 

- Strong & Statically Typed
- Simplicity 
- Fast Compile Times
- Garbage Collection - you don't have to manage your own memory, the go runtime shall help you manage it.
- Built In Concurrency Primitives
- Go compiles down to standalone binaries

##### How to install Go

Follow this [documentation](https://golang.org/doc/install) to learn how to install

##### Useful Links

To practice coding in the browser:

- [Playground](https://play.golang.org/)

Just like other languages, go has different packages that handle different functions.
- [Packages](https://pkg.go.dev/std)

To get help
- [Help](https://golang.org/help)

##### Understanding Go Code
```
package main

import (
	"fmt"
)

func main() {
	fmt.Println("Hello, playground")
}

```

Every application is structured into packages, for every file in go you will have to declare which package its part of. The code above, belongs to the `main package`. The `main package` is a special package as it is going to be the entry of your application.

The **import** statement is what we use to import additional libraries. In the above code we are importing the `fmt` library often pronounced as thumped.

From the `fmt` library we use the  `Println()` function to print the code
Run this code in the [Playground](https://golang.org/doc/install)
NPM packages for custom hooks that you wouldn't wanna miss out on
Tags: react, javascript, hooks
Published: 2021-11-06 08:00:54

Saloni : Hello, Shubh. Hooks have always been handy for me in react. They've made my job a lot easier. I wish React had more hooks than just useState, useEffect


Shubh : You can create your own custom hooks in react and there are some awesome custom hooks on NPM as well.

Let me tell you more about such hooks 🧵


The first one is **use-clippy**

useClippy is a TypeScript-friendly React hook for reading from and writing to the user's clipboard.


 [https://www.npmjs.com/package/use-clippy](https://www.npmjs.com/package/use-clippy) 


Second in this list is  **useScript**

It loads a third party script and returns a value when it's loaded or fails to load.


https://www.npmjs.com/package/use-script


Third is  **react-use-idb** (useIdb)

It is a react side-effect hook that manages a single indexDB item.

It's a drop-in replacement over useLocalStorage.

https://www.npmjs.com/package/react-use-idb


The fourth is my personal favourite and it is **use-dark-mode**

It's a custom React Hook which helps you implement a "dark mode" component for your application. The user setting persists to localStorage.

https://www.npmjs.com/package/react-use-idb


The last one is  **useDocumentTitle**


React Hook (using useEffect()) to set your document title.

https://www.npmjs.com/package/use-document-title

You can look for more custom react hooks on this website

https://reacthooks.org/


I hope I was able to help you out Saloni.

Saloni : Yes!! Thank you so much for telling me about it. I'm going to give you a like and a follow too!!
Hello World !
Tags: arizkinewbie, newbieteam, esaunggul, mulaiajadulu
Published: 2021-11-06 08:00:47

I am a student from Esa Unggul University in Informatics Engineering. I am looking for full-time opportunities. I'm very insterested for Programming Learning.

Saya memulai mengenal passion ini (IT) dari 2013 dan menekuninya sejak 2016 (SMP). Dari sana banyak proses yang saya alami, apalagi saya belajar secara OTODIDAK. So, asal ada niat semua bisa. 👍
#MulaiAjaDulu

𝘼𝙧𝙞𝙯𝙠𝙞𝙉𝙚𝙬𝙗𝙞𝙚.
Infinite Lights with Three.js
Tags: tutorial, javascript, webdev, programming
Published: 2021-11-06 07:38:05

A creative coding exploration into how to recreate the effect of a high-speed light in real-time using Three.js.

{% youtube hw_e5n1DqPo %}



Through this article, we’ll use Three.js and learn how to:
instantiate geometries to create thousands (up to millions) of lights
make the lights move in an infinite loop
create frame rate independent animations to keep them consistent on all devices
and finally, create modular distortions to ease the creation of new distortions or changes to existing ones
It’s going to be an intermediate tutorial, and we’re going to skip over the basic Three.js setup. This tutorial assumes that you are familiar with the basics of Three.js.



Read complete article here:- https://www.epicprogrammer.com/2021/11/infinite-lights-with-threejs.html
Airline Crew to Programming Journey
Tags: javascript, beginners, scrimba
Published: 2021-11-06 07:21:52

So I just finished Per Borgen's Javascript Full Course in Youtube via FreeCodeCamp's channel. My name is Miguel Cuaresma and I am an aspiring programmer with zero background in Tech/Dev line of work. I am a former flight steward and as we all know, airliners got really hit hard by this pandemic. Partner that living in a third world country, and it just feels like I've got nowhere to go. That's when I learned that programming can really upscale my career and help me in the life I've been dreaming of. I know I still have a lot to learn and I am ecstatic in this brand new journey of mine. As my way of giving thanks to Mr. Per Borgen, I decided to write this. I really enjoyed your course and your approach in teaching, Sir.
A Session on Git and GitHub.
Tags: opensource, github, git
Published: 2021-11-06 06:59:46

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vbb45rhlbkbickl3xf12.jpeg)
Heyo Everyone🌻! I am Shruti , Evangelist at Hack This Fall. I conducted a session on Introduction to Git and GitHub.For this session, I collaborated with my team i.e Shruti Arora (Speaker no 1) , Shivam Saini (Speaker No 2) and Vaniya Batra(Host). 

Most of the folks attending the session were new to Git and GitHub so they were quite interested to learn how Git and GitHub can be  essential tools to them. 

There were about 15-20 active folks who connected with us.

Topics covered -
  1) what is Git ? -Git is a version control system.t is a free and open-source version control system .

  2) why you should use Git-It is used to efficiently manage small to extremely big projects.

  3)Basic Git commands-  
      a)git init: The git init command creates a new Git repository. 
      b)git clone: The git clone command is used to create a copy of a specific repository or branch within a repository.
      c)git add:It is used to tracks your file and changes in Git.
      d)git commit: The git commit command takes a snapshot of the current state of the project's changes.
      e)git push : This command is used to upload git commits to a remote repository like Github.
      f)git checkout:checkout commands lets you navigate between the branches created by the git branch.

  4) What is GitHub? -GitHub is a site that hosts Git repositories, but it also has a lot of its own features. It is a web-based graphical interface for Git, which is a command-line application. 

  5) why you should use GitHub? - With the help of Github only , you do Open Source Contributions and is useful for your project management.

  6) Basic GitHub terms -
     a)Fork: Fork lets you create a copy of another user's repository that stays on your personal GitHub account.
     b)Main: When you create a new repository, it comes with a default development branch. 
     c)Readme: It is a text file that contains information about other files in a repository. YOu can customize this file .
     d)Repository: A Repository is a place where tour work will be stored in a directory or storage space.
     e)Pull request: It allows you to announce a change made by you in the branch. 
      

We also encouraged attendees to participate in Hack This Fall 2.0. At last the attendees also shared their feedback on how fruitful the session was for them.
Setup your own blog on top of GitHub
Tags: opensource, github, beginners, webdev
Published: 2021-11-06 06:07:38

Have you ever thought of creating your own blog in your own .dev domain that you could just share with anyone and forget?

Well, it has never been easier to create a blog. I myself have a separate blog on my domain and every now and then I end up redesigning the whole thing. However, the tedious part about maintaining a blog is every time you need to keep on moving your posts from one place to another.

This is why I came up with Emanates. Emanates is a tool that lets you build a blog **on top of GitHub** in just a few minutes.

## How does it work?

The idea is simple. There are two key things to know about Emanates:

1. Every GitHub Issue is a blog post
2. Every time an issue is created/updated/deleted a GitHub Action is run that builds the latest static blog and deploys it.

## Why Emanates?

Now, why should you go with Emanates instead of building your own blog?

Well, Emanates also comes with some of the latest features that people want in a blog:

- Comment support
- Built in SEO
- Support for automatic related posts (Emanates does that automatically, you just need to use the proper labels)
- Metadata supported
- Cover image supported
- Dark Mode (obviously)
- Everything is stored on GitHub, no hassles of databases and such.
- It is fast (it's a static site)

## Show me how it is

If you want to get a taste of how it looks like when it is live, check out the demo page:

https://emanates-demo.netlify.app/

Here are some images:

![Emanates Main page](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/n3tjslzsyaowc3a6rf5k.png)

![Blog Head](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rahk09s4ily5dk7kes8a.png)

![Blog content](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vxejw9wukiinentdvr3v.png)

## How should I start

Get started with Emanates by checking the GitHub repo here: https://github.com/emanates/emanates-web
On designing processes
Tags: productivity, productmanagement
Published: 2021-11-09 01:56:36

---
title: On designing processes
published: true
date: 2021-11-06 05:49:51 UTC
tags: productivity, productmanagement
canonical_url: 
---

Some notes on things to think about when designing processes:

**Clearly define the goals of the process** 
A process can either help the business or the customer, and everyone involved in the process must be able to clearly articulate who it is for, and how it helps them. Avoid the temptation to jump into designing a process before you've properly understood _why_ the process needs to exist in the first place.

**Name your process according to its outcomes** 
Call things names that remind people of their outcomes, not their outputs. Focus on what you want to _achieve_ with your process (versus what you want to _get done_).

When naming the outcomes of your process, make that a team activity. Naming things together is a fundamentally optimistic activity because it forces you to focus on the positive outcomes of your efforts. Naming your outcomes also helps the team navigate short-term conflicts, or even set the stage for short-term explorations in the future.

**Ask people what they would do if they had a deadline tomorrow** 
This is as essentially complex as the process might need to be. Once you have identified the path people would take in an emergency, try not to introduce more complexity into the system. Chances are if the regular flow takes much longer or is more complex, people will default to the emergency flow anyway.

Try to not accidentally make your processes more complex than they need to be.

**Complexity is sticky** 
Once you've introduced any complexity into your system, it's going to be very hard to take it away (mostly because change is hard). Generally, complexity in a system is distributed between people, processes, and tools. You can't take away existing complexity from one of these domains without introducing it into the others.

If you simplify an existing process, then you're either asking people to do a little more, or maybe you're introducing automation – which involves added tool complexity.

If you simplify what your tools do currently, then whatever load you shed from your tools must be handled either by added process complexity or by people.

**Do things the hard way** 
Design your processes for people first, and add technology as you go. Don't hard-code technology into your process up front. You're going to push yourself into a corner when a parallel process comes up 3 years later and uses technology that doesn't play well with what you're using now; you'll end up creating technology or information silos (or more likely, both).
Random Facts: Async Programming in .NET
Tags: csharp, dotnet, programming
Published: 2021-11-06 05:48:41

This post aggregates random tidbits and their sources to pick up on a couple of Async Programming Concepts. I did a deep dive whose notes can be found [here](https://github.com/MokoSan/DeepDives/tree/main/AsyncAwaitProgrammingInDotNet).

# ConfigureAwait

General rule of thumb, use ``ConfigureAwait(false)`` while awaiting a task if the control doesn’t need to go to the original captured context. Without ``ConfigureAwait(false)``, the next steps are posted on the original captured context i.e. ``SynchronizationContext.Post(..)``. This can also reduce impact on the UI thread and prevent deadlock conditions.

> “As a general rule, every piece of code that is not in a view model and/or that does not need to go back on the main thread should use ``ConfigureAwait`` false.”

Good references: 
1. https://johnthiriet.com/configure-await/
2. https://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Async-library-methods-should-consider-using-Task-ConfigureAwait-false-

# Thread Affinity

Thread that instantiates the object is the only thread that is allowed to access and mutate the members.

Good reference:
https://www.linkedin.com/learning/advanced-threading-in-c-sharp/thread-affinity?u=3322

# AutoResetEvent vs. ManualResetEvent

Thread-safe signaling mechanism where ``WaitOne()``: Blocks the current thread until the ``EventWaitHandle`` sends the signal of Set().

> The difference between a tollbooth and a door. The ``ManualResetEvent`` is the door, which needs to be closed (reset) manually. The ``AutoResetEvent`` is a tollbooth, allowing one car to go by and automatically closing before the next one can get through.

Good Reference: 
https://stackoverflow.com/questions/153877/what-is-the-difference-between-manualresetevent-and-autoresetevent-in-net

# CountdownEvent

``IDisposable`` synchronization primitive that signals when the count reaches 0. ``Signal()`` decrements the count and the threads that are blocked via ``Wait()`` are released when the count = 0.

# TaskCompletionSource

``TaskCompletionSource`` is a class which wraps a Task whose state we can manually control.

Good References:
1. http://www.levibotelho.com/development/async-processes-with-taskcompletionsource/
2. Use Case: https://stackoverflow.com/questions/15316613/when-should-taskcompletionsourcet-be-used

# IO vs. CPU Bound and Async Programming in CSharp

For I/O-bound code, you await an operation which returns a ``Task`` or ``Task<T>`` inside of an async method.
For CPU-bound code, you await an operation which is started on a background thread with the ``Task.Run`` method.

# Background Threads

The background threads will stop executing when it either finishes executing the delegate, or when there are no more foreground threads in the entire process i.e. the process will disallow the continuation of the background thread execution if the foreground threads have reached the end of the process.
Rapid Environment Editor 設定 Windows 環境變數的工具
Tags: windows
Published: 2021-11-06 04:26:14

本篇介紹一個幫助我們設定 Windows 環境變數的小工具 [Rapid Environment Editor](https://www.rapidee.com/)。

## 環境變數

環境變數指的是儲存於 OS 層的變數，變數設定的目的可能是作業系統自己工作所需而儲存的，或是某些 app 也會去讀取環境變數來做出某些相對應的行為，更多的解釋可以參考[維基百科](https://zh.wikipedia.org/wiki/%E7%8E%AF%E5%A2%83%E5%8F%98%E9%87%8F)。

### Path

以最常見的 `Path` 這組環境變數為例，shell 層就會去讀取 `Path` 的變數內容，`Path` 這組變數裡面放的都是一組一組的路徑。Shell 在透過 <kbd>Windows</kbd> + </kbd>R</kbd> 或 cmd.exe 執行程式時，如果當時工作的路徑找不到那支要執行的程式，就會去 `Path` 內每一組路徑尋找，找到就怒跑起來，找不到就報錯。

## 環境變數的格式

在 Windows 下環境變數長這樣：

```
Path=C:\Windows\system32;C:\Windows
```

環境變數的內容，這裡的例子是路徑，注意每組路徑之間以「`;`」做為分隔符號。

## 編輯環境變數

環境變數儲存於 Windows 登錄檔裡，通常會透過特定的程式來做編輯，除了 Rapid Environment Editor 之外，Windows 自己也帶有環境變數的編輯工具，不過並不好用，這裡不多做介紹。

去 Rapid Environment Editor 網站下載安裝執行後，應該會看到像這樣的視窗：

![Rapid Environment Editor](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pl4oc1ohb3rzyv7ee2ja.png)

主要分成左右兩欄，左邊為系統變數，沒事不要動它；右邊是用戶變數，如果想要改 `Path` 的話，找到 `Path`，把 `Path` 展開，就可以對 `Path` 的內容作增刪改了，最後改完要記得存檔，並且有些環境變數必須重新開機後才會重載，要留意一下。