teleren/devto huggingface dataset:
Putting trust in your team & your processes
Tags: softwaredevelopment, teamwork, agile
Published: 2021-09-27 11:46:27

---
title: Putting trust in your team & your processes
published: true
date: 2021-09-27 11:41:55 UTC
tags: softwaredevelopment,teamwork,agile
canonical_url: https://medium.com/chingu/putting-trust-in-your-team-your-processes-dab7a650eda0
---

#### Sprint 5 — Monday

![](https://cdn-images-1.medium.com/max/1024/1*OMSUm9bgnno5I7g-Ws-W5Q.jpeg)<figcaption>Photo by <a href="https://unsplash.com/@coasteering_co_uk?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Coasteering</a> on <a href="https://unsplash.com/s/photos/trust?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption>

The final two sprints in any project are the most stressful. If you didn’t realize it before, it’s at this point you realize that _time is the worst enemy of any project_. However, you’ve also learned that teamwork and following a process, like Agile, helps you meet your objectives even when time is short.

In the last part of any project it’s important to continue following your process and to work together. As deadlines approach and you are rushing to complete features and fix bugs there is always a tendency to start _hacking_. Namely, to make changes outside of your process and team, and often randomly and without thought.

> REMEMBER that your greatest resource is your team

It can be hard to be open about concerns, issues, and to ask for help. We might view this as a weakness or a failure. But, It is a sign of maturity, strength and results in saving time, while increasing what you learn.

So, as tempting as it may be to start hacking away with “_guns a blazing_”, **_rely instead_** on your teammates and your process.

![](https://cdn-images-1.medium.com/max/1024/1*ZsGXeLr8rGkxonDPmTEOAg.jpeg)

### Before you Go!

Chingu helps you to get out of “_Tutorial Purgatory_” by transforming what you’ve learned into experience. The experience to boost your Developer career and help you get jobs. **_And it’s Free!_**

You can learn more about **Chingu** & how to join us at [https://chingu.io](https://chingu.io/)

* * *
Code to Low-code: It’s A Happy Journey
Tags: productivity, programming
Published: 2021-09-27 15:01:12

If you’re anything like me, then you appreciate what a superpower and privilege it is to write code. Coding, to me, is the ability to pour one’s ideas, emotions, and feelings into electronic devices and networks. It is a way to make one’s self manifest in the digital world.

If you’re even more like me, then you also worried when you heard about the rising trend of No-code/Low-code products such as Bubble. Because these are the kind of tools that threatens to make developers like you and me invalid. Or at least that was my first impression of them.
However, it would be arrogant of me to assume without trying it out myself. So I went ahead to work with a company named ToolJet(https://github.com/ToolJet/ToolJet) which is building an open-source low code platform to build internal tools for enterprises.

In addition to building the platform, I was tasked with using the platform to create internal tools for a large enterprise. I ended up delivering them a production-grade application which they now use to record and keep track of their service delivery, all within two weeks.
What should have taken several months of programming effort was done in two weeks, with minimal code. Contrary to what I expected to feel, I now felt even more capable as a developer: developers are now equipped to quickly come up with software products, iterate with several startup ideas without having to write thousands of lines of code. No-code/Low-code tools don’t relegate developers, it empowers us!

What the No-code revolution truly represents is perhaps the solution to a fundamental issue that the software development community has not addressed: It has factionalized into several cultures centred on different technologies that attempt to solve the same problems, making it difficult to abstract and automate features every app would need.
Let me try to draw an example: To develop a web front-end, we have React, Angular, Svelte, Vue, and so forth, all philosophizing the greatness of their fundamental technical decisions, which may very well have been made by some developer while he was drunk or stoned. And this, for instance, makes it difficult to build a universal login/sign-up mechanism that developers can just plugin with minimal configuration.

The bulk of the effort made in building software is currently about finding one’s way through this mesh of technologies, and in making them all work together, instead of writing code just where it matters. And this is precisely the selling point of low-code.
I started this write-up by sharing my experience, but let me happily upgrade it to an invitation to try out a low-code tool. And while you’re at it, ToolJet would be a good place to start.

NB: I use No-code and Low-code interchangeably in this article. However, No-code refers to application development without any code. While it is an ambitious proposition, I’m personally more inclined towards Low-code as it seems to solve a real issue with software development today, as opposed to No-code which focuses on arming non-coders with software development capability.
Remote Work: The Do's and Don'ts
Tags: remote, career
Published: 2021-09-27 14:58:40

As the world got hit by the pandemic as severe as the COVID-19,it was almost inevitable for everything to turn gloomy. Surprisingly, not everything did. The tech world quickly transitioned itself into remote work which to say the least, is a world of endless possibilities. You could be sunbathing in the Bahamas, while attending a corporate conference on your laptop. It really is the new synonym of comfort at work. However, burnout due to working remotely is also a reality, which must not be neglected. Therefore, let's have a look at the do's and don'ts to ace that remote career of yours!

#Be Patient
While working remote, it is highly likely that you would be working with peers from all across the globe and that is when the time zone complex will hit you. Your working hours will almost certainly be resting hours for some of your teammates. However, this is when your patience will be put to test. You must not lose your calm, and communicate all your wants with your team members effectively.

#Get office ready
Why should I get ready when I am working from my own living room, you ask? While this might sound silly at start, it improves productivity significantly. Getting ready for your remote job, as you would get ready while working at a conventional office. Plan your day in advance, set an alarm, take a bath and wear nice clothes. Now sit back, and watch how your mood gets uplifted, making you ready to ace your day at work!

#Set up your home office
While working from your living room is a luxury not everyone can afford, but you should avoid doing so despite of all your temptations. Instead, focus on creating a home office-a space dedicated for you to work remotely. This place should ideally be a corner of your house in which you are least likely to be disturbed. Make sure to ensure some  influx of sunlight to feel fresh. Add an indoor plant to your desk to stare at when your screen time gets too much. Personalize this space, after all this is that will be dedicated to your work, you don't want to have a boring work space or do you?

#Carefully craft your work schedule  
Introducing balance in your life is very important. Therefore, it is imperative to carefully carve out the timings that you will give to your remote job. Ideally, check up with your friends and family and align your schedule with theirs. Remote work already let's you work in isolation so you should select work timings for yourself that allow you to spend ample time with your loved ones for relaxion too.

With the plethora of opportunities that remote work offers, it is also quite challenging. However, with a carefully worked out plan of action, you can nail this are of working remotely!
Effective Java - Static factory methods vs Constructors 
Tags: java, books
Published: 2021-09-27 11:34:44

Most of the time when we want to obtain an instance of a class, we call the public constructor. But we can also have a static factory method to simply return an instance of the class. For example:
```
public static Boolean valueOf(boolean b) {
    return b ? Boolean.TRUE : Boolean.FALSE
}
```
## Advantages of using a static factory method
* They have names. It is easier for clients to understand what the method is for. Also normally a class can only have one constructor given one signature. Changing the order of parameter list to get away from this restriction is bad practice. Because static factory methods have names, they don't share this restriction. 
* Unlike constructors, they are not required to create a new object every time they are invoked.
For the example above, it uses the instance created in the class.
```
public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);
```
* Unlike constructors, they can return any subtype of the return type.
For example, the interface `java.util.Collections` has many implementations and most of them are exported via static factory methods. The classes of returned objects are nonpublic, eg. `EmptySet`. It is exported via a static factory method 
```
public static final Set EMPTY_SET = new EmptySet<>();
public static final <T> Set<T> emptySet() {
     return (Set<T>) EMPTY_SET;
}
```
## Disadvantages of using a static factory method
* Classes without public / protected constructors cannot have subclasses.
* These methods can be hard to find unlike constructors but there are some common names for static factory methods, e.g `from()`, and `of()`.

## When to use a static factory method
* When you need multiple constructors with the same signature.
* When objects are expensive to create.
* When you want the flexibility to return subtypes.

## Conclusion
In general, static factory methods are preferable than constructors. So think about them before using a constructor.
Write rust code without english
Tags: programming, rust
Published: 2021-09-27 14:35:09

You reading the title, might be wondering HOW CAN YOU CODE WITHOUT ENGLISH???? you might think that i could have forked rust and changed the compiler to accept other keywords, but no.

Rust, being a very awesome language, has a nice handy feature called **Procedural macros**, with which we can parse code at compile time the way we want. And the other day I came across the [Rouille](https://github.com/bnjbvr/rouille), and then i wondered, "hmmm which language i know which i can use to make something like this?", and then i thought lets make a hindi version of this (because i didnt know any other language). But understanding proc_macros and all wasnt something i wanted to do just yet without having the fun of writing some code in hindi.

![Fork](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ur3wv5k567id7gvq5732.png)

## Step 1: Remove french words to be replaced with hindi words ![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/n14zolmy7vc06v5zh14t.png) -> ![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nu5rvh6y1sodyaekm0og.png)
##### *(Yes i know that we are pretty light on the vocab, but making PRs wont hurt, please)*

## Step 2: Changing the readme.
**THE HARDEST PART OF THIS WHOLE PROCESS.**
Tho i managed to drag myself through it. And ended up with a semi-ripped off README :/

## Step 3: Trying to get people to try this (this part failed miserably).

I sent my dev friends the repo to try out....
they ignored me.... 😥

## Conclusion
If you find this cool go star [Rouille](https://github.com/bnjbvr/rouille) and [Zung](https://github.com/rishit-khandelwal/zung) and make PRs to add more words to the zung vocab.
Why Automated Legacy Modernization?
Tags: legacyappmodernization, legacymigration, mobile, cloud
Published: 2021-09-27 14:29:43

Enterprises across the world are facing the challenges with their aging legacy applications

**Learn more** : https://www.softwebsolutions.com/infographic-automated-legacy-modernization.html

We move applications from current computing environment to the cloud, may it be public, private or hybrid.

**Benefits of [legacy application modernization](https://www.softwebsolutions.com/legacy-application-modernization.html)**

* Real-Time Data Access And Backup
* Remote Workforce Compatibility
* Better Integration With Other App Ecosystems
* Readiness For Mobility and AI Strategies
* Increase Revenue Streams 
* Higher Scalability
* Enhance Security 
* Global Data Access
Rails + React
Published: 2021-09-27 14:27:26

I was really excited to start this project as it was going to put everything that I learned in the last 10 months from Ruby and JavaScript all together into one project. I decided to really test myself by making a budgeting app that I would use myself. This project turned out to be a lot harder then I thought it would be. In all it toke me about 10 days to finish the whole project. The app starts off asking the user to either signup or login. From there you have the main app where the transactions and budging takes place. The user can also head over to his own profile page and either read through his info or edit his username or email. 

the hardest thing that I had to overcome in this project was dealing with my rails and the belongs to and has many. The was I set up the transaction and budget model was that a transaction belongs to a budget and a budget has many. The transaction model also had its on account, which was a string with a given name that the transaction belonged too. The problem come in when I wanted to have a transaction without linking a budget to it as it would either add income or outcome from the account itself. Rails did not like this as it had to have an ID to be created, so after six hours I came up with creating a join table through a model to be created if there was a budget to be linked with a transaction. 

In all I really feel like this project has really strengthen me in my knowledge of Ruby and JavaScript.
與 SSH 同行
Tags: security, webdev
Published: 2021-09-27 14:24:40


```
學習緣由
在開始做 Side Project 的時候，因為我使用 create-next-app 時，
沒有用成 typescript 版，我的 mentor 幫我處理的時候，
發現現在好像需要用 ssh 才能 push 到 github 上，
然後中間過程半聽半懂的 XD，想說趁機來了解一下～
```
&nbsp;

## SSH 是什麼？

一個協定(protocol)，為 Secure Shell 的縮寫，
讓兩台電腦在網路(Network)上安全的傳輸

因為在網路上傳輸時，資料都以明文(plain text) 的方式遊走，很容易被竊聽(overhearing)或篡改(tampering)

在還未有 SSL 的古早年代，就常常有人利用嗅探攻擊(sniffing attack)來截取使用者密碼和資料並篡改，後續在 1995 年，塔圖·于勒寧(Tatu Ylonen)就開發了 ssh 協定，讓電腦資料傳輸可以更安全的進行


&nbsp;


## SSH 資料傳輸方式
在此協定下，資料傳輸的方式可以用把包裹寄給朋友來說明

![SSH data transfer](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/le6di2n9wav0fsi3p6vb.png)

1. 今天我想寄一個很機密包裹給朋友，要確保不能被別人拿走

2. 我先加一個鎖在自己的包裹上，再傳給朋友

3. 傳給朋友後，他看到我的鎖後，也加了自己的鎖

4. 我看到朋友的鎖後，將自己的鎖解除，再回傳給朋友

5. 朋友將鎖解除後，成功拿到包裹

&nbsp;

這樣一來，我們可以增加傳送過程中的安全性，
即使資料(包裹)在途中被別人截取，也因為被加密的關係無法解讀

但在這之前，我們需要將兩台電腦達成 SSH 連結，
才能進行上述的傳輸

&nbsp;


## 如何建立 SSH 連結呢？

SSH 連結採用 Client-Server 模型
此處的 Client 為本機 (local machine)，Server 為遠端機 (remote machine)
並用以下的流程，達成 Server 對 Client 的授權 (Authentication)
並成立 SSH 連結

&nbsp;

![SSH Authentication](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/az4pvjxfryx1htlubb0q.jpg)

&nbsp;

1. 在本機利用 [RSA](https://medium.com/starbugs/what-are-encoding-encrypt-and-hashing-4b03d40e7b0c) 的加密方式，產生一組公鑰(Public Key)和私鑰(Private Key)，為一對 SSH keys

2. 將公鑰放在 Server 上

3. Client 利用終端機等產生一組 ID，範例格式如下：
`ssh username@my_ip_address`
傳給 Server，要求 Server 建立 SSH 連結

4. Server 會用公鑰加密(encrypt)，產生一組隨機的**挑戰**訊息 (random challenge message)回傳給 Client

5. Client 會用私鑰將挑戰訊息解密(decrypt)後，回傳給 Server

6. 如果解密後的挑戰訊息回傳 Server 後相符，則 SSH 連結就成立了

&nbsp;

以上就是 SSH 的介紹，如果有其他想法也請大家不吝指教～


&nbsp;
&nbsp;

### 參考資源
- [GitKraken](https://www.youtube.com/watch?v=z7jVOenqFYk&t=78s)
- [jumpcloud](https://jumpcloud.com/blog/what-are-ssh-keys)
- [School Of Basics](https://www.youtube.com/watch?v=lRMAJwMQ0Vc)
- [Level Up](https://levelup.gitconnected.com/what-is-ssh-103f89e3e4b8)
- [Larry Lu Medium](https://medium.com/starbugs/what-are-encoding-encrypt-and-hashing-4b03d40e7b0c)
Setting up a new Ceph cache pool for better performance
Published: 2021-09-27 14:13:47

---
title: Setting up a new Ceph cache pool for better performance
published: true
description: In this video, we talk about how to set up a Ceph cache pool and tier your cache in order to improve read and writes. There is a lot of cache settings that we could cover but I will talk about the most important values you can set on a pool to cache your data in a good way.
tags:
cover_image: https://i.ytimg.com/vi/ySSaro0eRsg/maxresdefault.jpg
---

{% youtube ySSaro0eRsg %}

In this video, we talk about how to set up a Ceph cache pool and tier your cache in order to improve read and writes. There is a lot of cache settings that we could cover but I will talk about the most important values you can set on a pool to cache your data in a good way.
Making posts in react using json data
Published: 2021-09-27 14:20:32

Hello! I`m new on react and i want to make a website where i can make some post on landing page. I want to add new posts (an image, a tittle, and some description) when I add a post, it appears on the landing page. And when someone clicks this post to have his page that will have more description for him. Only the person who has the site can add new posts while for others it will be hidden. Can I do something like that using json data in react js. Without using the database
Insectoid Curve
Published: 2021-09-27 14:19:26

The following short article will discuss the **Insectoid Curve** - a parametric curve inspired by the **Scarabaeus** and **Cornoid**. I created this back in 2016 for fun. 

The curve itself is a weighted average of variations on both the Cornoid and the Scarabaeus. The equation is parametric, with {% katex inline %}\theta{% endkatex %} as the parameter in a range from {% katex inline %}0{% endkatex %} to {% katex inline %}2\pi{% endkatex %}.

{% katex %}
r = b \cos(2 \theta) - a \cos(\theta)
\newline
x_1 = 2|r \cos(\theta + \pi/2)|
\newline
y_1 = \text{atan}( r \sin(\theta 2))
\newline
x_2 = c \cos(\theta) (1 - (2 \sin^2(\theta))
\newline
y_2 = c \sin(\theta) (1 + (2 \cos^2(\theta))
\newline
x = x_1 d + x_2 e
\newline
y = y_1 d + y_2 e
{% endkatex %}

Values {% katex inline %}a,b,c,d{% endkatex %} and {% katex inline %}e{% endkatex %} all range from {% katex inline %}0{% endkatex %} to {% katex inline %}1{% endkatex %}. In the below image these values were simply randomized:

![Insectoid Plots](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/70bclbtmayze4q2sx98t.jpeg)

Note each of the above plots is actually the result of {% katex inline %}4{% endkatex %} randomly generated plots on top of one another and increasingly offset on the {% katex inline %}y{% endkatex %} axis (slightly).

## Interactive Version
Click the below plot - values {% katex inline %}a{% endkatex %} through {% katex inline %}e{% endkatex %} will be randomized.

{% codepen https://codepen.io/ZevanRosser/pen/MWozLdE default-tab=js,result %}
_The code here is a bit strange, something I speedcoded to quickly create responsive shapes/plots. I may revisit it some day, but for now it remains a bit of an esolang api._

Again, this is {% katex inline %}4{% endkatex %} plots on top of one another. To render this plot with a single layer hold your **shift** key and click.

## The Scarabaeus and Cornoid

The original equation for the **Scarabaeus** curve in polar coordinates is:

{% katex %}r = b \cos(2 \theta) - a \cos(\theta){% endkatex %}

![alt](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/opv1unnaadsxeivvcslv.png)

...and the **Cornoid** in parametric form:

{% katex %}
x = a \cos (\theta) (1 - 2 \sin^2(\theta))
\newline
y = a \sin (\theta) (1 + 2 \cos^2(\theta))
{% endkatex %}

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

## Quick Background

The original impetus for the creation of the **Insectoid Curve** was to create a curve that had features similar to an insect - specifically a beetle. After combining the **Cornoid** and **Scarabaeus** the result you see here is the result.
Angular Development mocking External Calls
Tags: angular, json, typescript, javascript
Published: 2021-09-27 14:14:39

---
title: Angular Development mocking External Calls
published: true
description: 
tags: Angular, JSON, TypeScript, JavaScript
Series: Angular
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/t51oo2vnhkaw439u8ng0.jpeg
---

On a previous client project, I saw a use of local JSON for quick development that was horrible in that particular definition. I've refined the definition into something I can use more efficiently.

## Angular Configuration

First, in the `tsconfig.json` file at the root of the project, I clean up the imports and allow JSON files to be resolved on import, as shown ...

```json
{
  "compilerOptions": {
    ...
    "allowSyntheticDefaultImports": true,
    "resolveJsonModule": true
   ...
  }
} 
```

## Assets Used

In the assets folder, I define the mock-data in the following path ...

```script
assets/mock-data/api/
```

For this article, assume there is a `users.json` file in the api folder.

## Project Configuration

Within the project, I create a `config.json` file that can be imported.

```json
{
  "features": {
    ...
    "useLocalJSON": false,
    ...
  }
} 
```

This file is imported as such.

```typescript
import config from '@core/config.json';
```

By referencing `config.features.useLocalJSON`, we can quickly determine if we are using the local JSON files or calling out to the appropriate API endpoint with a single-line toggle.

## Use of `useLocalJSON`

Here's some of the code in my api-service.

```typescript
import hostnames from '@core/constants/hostnames.json';

...

getURL = (key: string): string => {
  if (this.useLocalJSON) {
    return hostnames.localJSON.BASE + hostnames.localJSON[key];
  } else {
    ...
  };

  getUsers = async (): Promise<Array<User>> => {
    const key: string = 'get-users';
    const url: string = this.getURL(key);
    try {
      const users: Array<User> = await this.http.get<Array<User>>(url).toPromise();
      return users;  
    } catch (error) {
      this.triggerErrorMessage(error);
      return Promise.resolve([]);
    }
  };
```

As yo can see here, the `getURL` function assembles the URL based on the `key` from the `hostnames.json` which looks something like this.

```json
{
  "localJSON": {
    "BASE": "assets/mock-data/api/",
    ...
    "get-users": "users.json",
  }
}
```

## Summary

So, with all this code we are able to serve the code and with a single feature flag, start using local responses rather than pure API calls. This allows me to work ahead of the backend team, or accommodate issues in the development environment, such as the API endpoints being down.
Trello Webhook Manager
Tags: trello, webhooks, api
Published: 2021-09-27 13:59:38

tl;dr [I made a UI for managing Trello Webhooks](trellowebhookmanager.com/).

In the past I’ve worked on several iterations of a webhook manager for myself. Today, I thought I would share it to the dev community here in case anyone might find it useful.

I tried to make it in one single html file. This may not be best practice, but something about the simplicity and portability really appealed to me. 

For example, you can take the html file and host it yourself somewhere, or use the link above or you can take the file and put it on your machine, run it locally and you’re still good to go. Lots of options.

I went as far as registering a domain for it and placed my single file out there for anyone to use. Here’s the [github repo](https://github.com/fischgeek/trello-webhook-manager/tree/release) for those that are interested.

Anywho, have a good one folks!