teleren/devto huggingface dataset:
Where Do Cloud/DevOps Folks Like to Hang Out?
Tags: aws, cloud, devops
Published: 2020-06-29 14:46:22

---
title: Where Do Cloud/DevOps Folks Like to Hang Out?
published: true
description: 
tags: #aws #cloud #devops
//cover_image: https://direct_url_to_image.jpg
---
Although I enjoy web dev, I am primarily a cloud/devops guy. I have been hanging out here for a few weeks but I don't see a ton of activity around cloud and devops topics.

Wondering where do these folks like to hang out? Anyone interested in trying to grow that community on here with me?
Kanban: The End Of Status Updates
Tags: agile
Published: 2020-06-29 14:41:36

## The Problem.

There are stakeholders who ask for status updates in every tech project. Whether they are managers, project managers, or investors, someone always wants an answer to the question: "Where are we now with this project?" The common solution is to get everyone together at the same time to discuss the project status, sometimes known as a "status update meeting".

Why are status update meetings a problem? If the project's developers are in a meeting then they are not writing any code. However, the various stakeholders can have good reasons to want to know the status of an ongoing project. Any solution to this problem must balance stakeholder concerns with maximizing development speed.

## The Solution.

The kanban board is an effective solution to status reporting that removes the need for a status update meetings entirely. The general idea of a kanban board is to always have an accurate summary of the current status of the project.. Therefore, if a team has a kanban board, then status may be communicated through the board rather than in a meeting.

A basic Kanban board will organize all project tasks into three categories: To Do, Doing, and Done. Every time a developer starts or finishes a new task, they will update the board to reflect this status change. If a stakeholder wants to know the big-picture status of the project at any point in time then they only need to look at the board.

![](https://i.imgur.com/gaPrvUZ.png)
Example Kanban Board

Kanboard boards can be physical or virtual. Many ticket tracking software solutions have built-in kanban boards that update automatically to reflect the status of the corresponding task ticket. Does your team's software not have this feature? No problem! A kanban board can be as simple as putting stickey notes up on the wall of an office!

After you adopt a kanban board, please resist the urge to have daily status meetings where everyone reads the kanban board together! This practice is still a status meeting and eliminates all the benefit that a kanban board can provide while adding the extra work of building and maintaining a kanban board.
To The Young Female Software Engineer With Her First Job Offer
Tags: womenintech, codenewbie, softskills, softwareengineering
Published: 2020-06-29 14:34:53

First and most important: Congratulations! You have put in the effort, struggled through terrible professors, long nights, and might have a slight addiction to coffee. But you made it!
While in my sophomore year of college, I had the opportunity to become a QA Analyst at a small up and coming Mobile Application Company. Now, as a senior in college, I am now a Lead Software Engineer at the same company. I transitioned to a lead development position very quickly which is not always the case, but I have been forced to learn how to adapt. Here is some unsolicited advice you may not have seen while nervously awaiting your big first day:

### 1. It is okay to be feminine.
Looking feminine is not for everyone, but if it is something that makes you comfortable, confident, and most important happy: GO FOR IT! There is a preconceived notion in this industry on how engineers, especially female engineers should look. But if wearing a skirt or doing your make up makes you happy, do it! If you are more of a band t-shirt and jeans, rock it! Be yourself, even if it challenges the ‘status quo’ (Look into the campaign #ilooklikeanengineer)

### 2. You should be heard
Software engineering is a team sport. A team should be based in mutual respect, where people are comfortable sharing their well thought out opinions and they know the others will actively listen. But during many social experiments, researchers still find that women are interrupted more than their male counterparts. From my experience, this is still the case in Engineering, from classrooms to meeting rooms. Remember, you should be heard. Your opinion has value.

### 3. Take risks
Risk is everywhere in this industry: Risks in deploying code, to making certain calls on storage levels, to choosing if you work for a start up or an already successful and large company. Be impressive.

### 4. Don’t weaken your own ideas.
Ditch the filler language! It does nothing to strengthen our ideas, in fact it starts to weaken them. If I tell you “I think xyz idea will maybe work better that ABC”, it shows hesitation and that I have not convinced myself of my idea. But if I say “XYZ will work better than ABC because….”. It shows confidence and assurance that will make it easier for you to keep peoples attention and persuade them to your ideas easier.

I wish I could give you all the advice you would possibly need in your career. But I will leave you with those main important four, because if you are anything like me, this is one of ten articles on the subject you will be looking at tonight! Good Luck!
Are we losing the Basics???
Tags: discuss, codingbasics
Published: 2020-06-29 14:31:51

---
title: Are we losing the Basics???
published: true
description: 
tags: discuss, codingbasics, discussion
//cover_image: https://direct_url_to_image.jpg
---
Being in the Tech field, We are *"Standing on the shoulders of giants"*. Our IDEs are powerful in fact normal Text-Editors are also Powerful with thousands of extensions making coding as simple as possible.

So, do you think that being surrounded by all these powerful tools, we are losing the basics?

### An ancient example:

Since we have phonebooks we don't remember anyone's phone number anymore.
Creating a dynamic selection list with TTY-Prompt
Tags: ttyprompt, dynamicprogramming, cliapp, ruby
Published: 2020-06-29 14:17:07

When writing a CLI application there are some Ruby gems out there that make a big difference. TTY-prompt is without a doubt one of the most popular CLI gems out there - and for good reason. TTY-prompt is extremely helpful for reducing user error which makes your code harder to break since the user is no longer typing directly into the command line to make a selection. And, I think, improves the user experience which is important even in a small-scale application like this.

![example of tty-prompt in action](https://dev-to-uploads.s3.amazonaws.com/i/o8k75r8t5sw67hoi3hk0.png)

Basically, the TTY-prompt gem works by reformatting the output to let the user scroll through a list of options and make a selection. Here is a classic example of the TTY-prompt in action:

![Statically coded example that you will find in the documentation](https://dev-to-uploads.s3.amazonaws.com/i/txfnewidemyynw9v71ko.png)

However, if your app is like mine you’ll need these lists to be dynamic. If your seed data changes, or if the selection list is determined by user input, you’ll code that’s more flexible than the examples given to you in the TTY-prompt documentation, that looks a lot like the main-menu example above.

## Creating a dynamic list with TTY-prompt:
![Dynamically coded tty prompt examples](https://dev-to-uploads.s3.amazonaws.com/i/c1724iuayhorm0hc0sgq.png)

My partner and I managed it by splitting it up into three methods:
1. Create a dynamic method that returns the selections you want to display like “list_farm_names.”
2. Create a method that displays the selections using TTY-prompt like “print_farm_name_list.”
3. Create a method that returns the selected information like “farm_selection(selection).” This will look different depending on what data you are returning and how your schema is set up. In our example, we wanted to return the farm’s website URL if one existed, a list of available products at that farm, and the quantity.
What is __name__ in Python? 
Tags: python, beginners, tutorial
Published: 2020-06-29 14:13:30

You’ve most likely seen the following piece of code at the bottom of a Python script:

```python
if __name__ == ‘__main__’:
```

You've most likely seen the following piece of code at the bottom of a script:
 
```python
if __name__ == '__main__':
   # some code here
```
 
While this line of code may seem mundane, it's actually quite powerful! It allows you to run python code as standalone scripts or import them as modules.
 
## How does it work?
 
The `__name__` variable is a special "dunder" or magic variables in Python. Dunder stands for "double underscore", hence the two underscores on both sides.
 
Dunder variables hold special meaning in Python. The value of the `__name__` dunder variable depends on how you execute the script.
 
If you run your script from the command line, the `__name__` has the value `__main__`.  If you import it, it will contain the name of the script.
 
Let's see how this works through code.
 
## A simple example
 
Suppose you're making a simple greeter module. You want it to behave as follows:
+ When it's run as a standalone script, it asks the name of the user and prints "Hi, {user}!". It repeats this until the program exits.
+ When it's imported, it exposes a `greet` function that can create a greeting given a name

Seems simple enough! Let's code it.
 
```python
# greeter.py
 
function greet(name):
   print(f'Hi, {name}!')
 
print('__name__ is:', __name__)
 
if __name__ == '__main__':
   while True:
      print("What's your name?")
      name = input('> ')
    
      if name == 'q':
        break
    
      greeter(name)
```
 
When you execute this script, you'll see the following output:
 
```bash
__name__ is: __main__
What's your name?
> Adrian
Hi, Adrian!
```
 
The magic happens before the code runs. Python assigns the value `__main__` to `__name__` since the script is ran standalone.
 
## Importing our greeter function
 
What happens then if you import this script as a module from another script?
 
```python
# client.py
 
from greeter import greet
 
names = ['Jeff', 'Annie', 'Britta']
 
for name in names:
   greet(name)
```
 
When you run this, you should see the following output:
 
```bash
__name__ is: greeter
Hi, Jeff!
Hi, Annie!
Hi, Britta!
```
 
Since we imported `greeter` as a module, Python assigned the name of the module, i.e. greeter, as the value of `__name__`. Due to this, the code block inside `__main__` never gets executed.
 
## Conclusion
 
Congratulations! You made a Python script that you can execute standalone or as a module. All you had to do was to include the following `if` statement:
 
```python
if __name__ == '__main__':
 # some code here
```

You can find the sample code used in this article right [here](https://github.com/adrianmarkperea/what-is-name-in-python).
 
As a recap, this works because when you run a Python script, the `__name__` dunder variable is:
+ `__main__` if you run the script from the command line
+ The name of the module if you import it from another script

I hope this short tutorial was helpful!
Instantiation in Javascript: Pseudoclassical Style
Tags: instantiationpattern
Published: 2020-06-29 13:58:40

Instantiation patterns refer to the way instances of objects are created. There are different instantiation patterns and these patterns have different opinions of how a class creates a new instance of an object. This article will cover **pseudoclassical instantiation**.

All instantiation patterns have the same following functionality:

* Creates a new object.

* Creates properties which are methods for the newly created object.

To create a new **instance** in pseudoclassical style, we must start with a **class** function. The class is the constructor function that creates instances of new objects that inherits properties from the class prototype. We can metaphorically think of this class as a carpentry school. This school has all the knowledge that students need to build things.

For example, here we have a class called BuildDiningSet. This function has a prototype property which contains methods for building furniture and other methods.

```javascript
class BuildDiningSet {
  constructor(chair, table) {
    this.chair = {};
    this.table = {};
    this.chairCount = 0;
    this.tableCount = 0;
  }
}
```


 As a result of an affiliation with the school, the students that go to that school will have inherited the knowledge of building different things upon graduation. Thus, as a result of invoking our class, we create new instances that will inherit the prototypes of our class.

The properties and methods are defined on the prototype property on the objects' class, not the object instances themselves. Each new instance refers back to the prototypal chain to access the prototype property of its' class. 

```javascript
BuildDiningSet.prototype.makeChair = chairType => {
  this.chairCount++;
  this.chair[chairType] = chairType;
},

BuildDiningSet.prototype.makeTable = tableType => {
  this.tableCount++;
  this.table[tableType] = tableType;
};
```
Now that our class has methods on its' prototype, we are ready to create new instances. To create a new instance with must use the "new" keyword. Our graduating students now know how to build tables and chairs.

```javascript
const carpenter1 = new BuildDiningSet(tallChairs, roundTable);
carpenter1.makeChair();
carpenter1.makeTable();
```


Now we have a graduating student called carpenter1 that knows how to build tables and chairs. When the graduate goes to work he refers back to what he learned in school to perform the function. 

When using the new keyword, it binds the keyword this to the new object being created and thus gives the new object all the properties specified in the class.

Pseudo classical instantiation is the most advanced method of object creation. With the use of syntactical sugar, it makes it so you don't have to do as much code writing as you would when using other instantiation styles.
Offbeat
Tags: javascript, showdev
Published: 2020-06-29 13:47:54

This is one of my products for the Indian crowd and a little bit for outside of India.But there are good quality  videos chosen from Youtube(Embedded).

##[Project-Link](https://bit.ly/00ffbeat)

####Status : Rarely update | Nearly dead | Project is old so, Some video(s) might be removed or unavailable

Share your thought !!!
Reinvent Loyalty Program using  Blockchain Technology
Published: 2020-06-29 13:44:24

Blockchain can be truly transformative for the Loyalty Program industry with enhanced efficiencies, reduced costs, and enhanced brand loyalty. A number of startup companies like KSLoyalty Platform and few other startup's are implementing the Blockchain Loyalty Program by addressing few key points.

There are 5 Things to know about Blockchain Based Loyalty Program
**1, Decentralized Loyalty Program**
**2, Cost Cutting Efficiencies** 
**3, A real-time Blockchain Loyalty Program**
**4, Increased security leading to enhanced customer loyalty** 
**5, A Ocean of new opportunities for businesses**

**1, Decentralized Loyalty Program**  — A decentralized, trustless ledger would actually centralize the customer’s loyalty programs. This Blockchain Loyalty Program would give Loyalty providers the ability to decide how and with whom the customer uses these rewards. The customer will have the ability to access and manage the ledger with no friction.

**2, Cost Cutting Efficiencies** — Loyalty programs are expensive and tedious, demanding a significant investment of time and money on both technical implementation and cost of rewards. Blockchain incurs upfront expenses on three major levels–system management, transactional , and customer acquisition. A BC powered loyalty program would reduce costs associated with errors and fraud by using smart contracts which would ensure secure, traceable and transparent transactions.

**3, A real-time Blockchain Loyalty Program** — One of the inherent features of Blockchain is that it enables the transaction to be recorded and accessed by multiple involved parties in near real-time. This makes the process of coordination between loyalty rewards program provider and consumer more efficient and instantaneous. With Blockchain Loyalty Program, customers won’t have to wait to be rewarded by points but could potentially receive and redeem them in real-time.

**4, Increased security leading to enhanced customer loyalty** –Transactions on a Blockchain ledger are cryptographically secured. Every transaction ever made on the Blockchain are immutable and time-stamped, thus transactions are easily trackable. No transaction made is irreversible, therefore preventing double spending, fraud, abuse, and any other type of manipulation of the transactions are not possible.

**5, A Ocean of new opportunities for businesses** — With an interlinked loyalty network, large loyalty rewards program providers will have unique opportunities to offer value-added services to other businesses. A Blockchain Loyalty Program would no longer force customers to spend their loyalty points with a specific brand. Customers can even sell their points, tokens for fiat and spend the money in the real world!
How I passed the Azure Fundamentals with mostly free content 📑
Tags: azure, cloud, beginners
Published: 2020-06-29 13:22:57

So I recently took the #AzureCertified challenge and started preparing for the AZ-900 Azure Fundamentals certificate. It's the starting point in Azure certifications. 
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/lbmcreuby4ur6tm733tb.png)
Fortunately I was able to pass it last night with a score of 880 (not great, but I will take it!)

## Courses:
Again @andrewbrown to the rescue! Andrew published his free AZ-900 course on [FreeCodeCamp Youtube Channel](https://youtu.be/NKEFWyqJ5XA).
I also went through the [Microsoft Learn path for Azure Fundamentals](https://docs.microsoft.com/en-us/learn/paths/azure-fundamentals/) and must say that I loved this new approach of learning! Two great things about Microsoft learn:
- Knowledge Checks
- Hands On labs

## Preparation:
I announced that I will be taking the Azure Certification on Twitter. This helped me connect to some great motivated individuals that are pursuing the same path. I was motivated!
I did study around 30-60 min daily for about 20 days.
The tough part initially was that I would compare AWS services to Azure and then forget the exact names of Azure Services. This can be an issue, since exam had some questions about which service to use in which scenario, and the options would have similar names (not exact).
So I started taking notes and used Andrew's course for my revision after going through the Microsoft Learn modules.

## Get Certified 💪:
So the two resources that I used are totally free, also you can sign up for the Azure Free Tier, but not necessarily, since the Microsoft Learn Platform launched sandbox environment for you! Isn't that great!
Also, I was able to sign-up for one of the Microsoft Virtual Training sessions where they offered free voucher to take the AZ-900 exam! I don't think they are doing these anymore right now, but I would keep an eye. 
Also, I will be updating my [notes here](https://rishabkumar7.github.io/CloudNotes/)
Good Luck with your Cloud Journey ☁ !
Write Web Form Data to Airtable Databases with WayScript
Tags: tutorial, wayscript, database
Published: 2020-06-29 13:03:23

Introduction
------------

Collecting data from forms and saving it manually can be a harassed task. If you are sick at manually collects data, integrate Wayscript Forms with Airtable can save you a lot of time.  
Today, we’ll collect data from Wayscript Form and seamlessly save it in Airtable.

Prerequisites
-------------

No prerequisites but here are some contents you might find uselful :

*   [](https://docs.wayscript.com/library/triggers/form-trigger)Working with Form Trigger
*   [Working with Airtable](https://docs.wayscript.com/library/modules/airtable)

Trigger
-------

Wayscript platform comes with a Form trigger. Working with this, we can build any forms with any fields to collect what we want. Add it as Trigger and let’s add a title and a description to create context for the users.

![Configuring Form Trigger](https://cdn.wayscript.com/blog_img/111/1.png)

After this, we are going to add Form inputs.  
You can add as many Form Element you want. Wayscript allows you to choose the type of input. Here we’ll work with radio input only.

![Radio input](https://cdn.wayscript.com/blog_img/111/2.png)

![Radio input](https://cdn.wayscript.com/blog_img/111/3.png)

![Radio input](https://cdn.wayscript.com/blog_img/111/4.png)

After finishing the forms, be sure the password protection is on, so anyone can access the form without a password.  
Here is how the page should look.

![Form Page](https://cdn.wayscript.com/blog_img/111/5.png)

The next step will be to configure Airtable.

Airtable
--------

To use the Airtable module, we need to configure it.  
You’ll provide your API key, Base Key, and the name of the Base. Check the documentation [here](https://docs.wayscript.com/library/modules/airtable#setting-up-your-airtable-account) to see how to configure it.

![Airtable API](https://cdn.wayscript.com/blog_img/111//6.png)

We want to write data, that’s why we’ve chosen the Submission Type to Build Data.  
The next step is to add the inputs. My table looks like this.

![Table Image](https://cdn.wayscript.com/blog_img/111/7.png)

We must add the columns and link them to each related inputs in the form.

![Fields inputs](https://cdn.wayscript.com/blog_img/111/8.png)

Done. Be sure the trigger is on, and now you have a form integrated with Airtable ready to collect data.

Conclusion
----------

Check the form of this article [here](https://23015.wayscript.io/). Questions about this script or anything else? Join our [discord](https://discord.gg/VWbXSbj). We're always around to help. If you want to work the full script template, just find it [here](https://wayscript.com/user/mangabo_kolawole/5OKNaT47).