teleren/devto huggingface dataset:
Xamarin Santa Talk Challenge with Azure Functions Winner in Microsoft
Tags: awards, azure, azurefunctions, xamarin
Published: 2020-02-28 05:13:34

---
title: Xamarin Santa Talk Challenge with Azure Functions Winner in Microsoft
published: true
date: 2020-01-11 17:58:00 UTC
tags: Awards,Azure,Azure Functions,Xamarin
canonical_url: https://logeshpalani.blogspot.com/2020/01/xamarin-santa-talk-challenge-with-azure.html
---

[![](https://1.bp.blogspot.com/-Dn1Ht93BEmw/XlaxC1R9Z3I/AAAAAAAAQLA/SZSS2K1C_LoAmGgjxkMuSd04fFfPaNdlwCLcBGAsYHQ/s640/Santa%2BTalk%2BUI%2BChellange%2BWinner.PNG)](https://1.bp.blogspot.com/-Dn1Ht93BEmw/XlaxC1R9Z3I/AAAAAAAAQLA/SZSS2K1C_LoAmGgjxkMuSd04fFfPaNdlwCLcBGAsYHQ/s1600/Santa%2BTalk%2BUI%2BChellange%2BWinner.PNG)

  

  

I'm very much happy to receive my winner swag from Microsoft. Thanks to this community that I was selected as a member of better usage of Azure Function with Xamarin. I feel very happy and Thanks for your support and guidance. 

  

Here is a link my for PR  - [Github Repos PR](https://github.com/codemillmatt/santa-talk/pull/10)

  

All the participants PR here - [https://github.com/codemillmatt/santa-talk/pulls](https://github.com/codemillmatt/santa-talk/pulls)

  

Once again Thank you
Make animated maps- L7 2.0 a WebGL-based open-source visual analysis and development framework is released
Tags: map, gis, data, webdev
Published: 2020-01-11 17:55:13

![L7地理可视化动画支持](https://gw.alipayobjects.com/mdn/rms_855bab/afts/img/A*f0rgQYQR_d0AAAAAAAAAAABkARQnAQ)

L7 is a WebGL-based open-source visual analysis and development framework for large-scale geo-spatial data, which is launched by the AntV data visualization team of Ant Financial. L7 focuses on the visual expression of spatial data. Graphic semiotics is the theoretical basis, which transforms abstract and complex spatial data into 2D and 3D symbols, and achieves rich visual expressions through visual variables such as color, size, volume and texture.

[GitHub](https://github.com/antvis/L7)

[original article](https://medium.com/@lzxue/make-animated-maps-l7-2-0-7bc28d2e1212)
Client side validation with the Pattern Attribute
Tags: todayilearned, webdev, html
Published: 2020-01-11 17:43:25

Hello Devmates, 👋

Today I learned about the client side validation using 
#The Pattern Attribute
It is used to provide a [regular expression](https://regular-expressions.info) (regex) to the input element of HTML. This regex is automatically checked just like a required attribute is checked in HTML.

It works with the input types including text, search, url, tel, email, and password.

Here is a pen demonstrating an email input which only accept **secure** emails:

{% codepen https://codepen.io/pagalprogrammer/pen/GRgddzZ %}

**Note**: Never rely on only client side validation. Server Side validation is important from the security perspective. (I know this is obvious, Don't give me that look 😐)

You may want to connect with me on [twitter](twitter.com/codewithankit) or checkout my #devdiaries on [instagram] (instagram.com/pagalprogrammer).

####Good night 😴😴 from India

Reference:
*https://www.w3schools.com/html/html_form_attributes.asp*
Is JAMstack antithetical to Wordpress?
Tags: jamstack, jamuary
Published: 2020-01-11 17:38:59

Wordpress is the most popular way of serving content on the web. [According to W3Techs](https://w3techs.com/technologies/details/cm-wordpress), WordPress is used by over 35.5% of all websites online and is one of the [fastest growing CMS-es in the world to date](https://wordpress.org/news/2019/03/one-third-of-the-web/). In spite of its popularity and how beloved its portability and extensibility is in the world of CMSes, the traditional WordPress model butts up against the JAMstack approach of building sites as statically as possible. Traditional WordPress sites are built using a LAMP architecture, which stands for Linux, Apache, MySQL and PHP. As the name suggests, a LAMP stack requires an apache server and linux configurations to handle any routing and serving of static assets. It moreover relies on PHP running on the server to process requests and render pages and assets on the fly. The JAMstack presents a critical change to this approach by moving up a layer. Instead of giving servers the reins to render assets “dynamically”, the JAMstack skews in favor of the client and browsers run the show. 

When it comes to speed, security, and maintainability the JAMstack comes out ahead. WordPress’ reliance on servers in addition to its deep investment in plugins has made it far slower, and more vulnerable to attack than many of its contenders. Attaining the benefits of speed and security however doesn’t have to mean abandoning WordPress altogether. A key way to transition to the JAMstack while still using WordPress is to use it like a headless CMS with the help of the WordPress REST API. The API turns content saved in WordPress into a consumable API that developers can then use alongside a static site generator or framework of their choice. This not only makes a site more and secure, it also enables developers and content authors to contribute without getting in the way of each other. 

For more on working with the JAMstack and WordPress, check out [this case study covering how web agency WayFx increased Perfect Keto’s site speed by over 87%](https://www.netlify.com/blog/2019/05/16/wayfx-deploys-lightning-fast-headless-wordpress-to-netlify/?utm_source=devto&utm_medium=wayfxcasestudy-div&utm_campaign=devex).
Hello World Web server in Flask vs Express
Tags: flask, express, web, webserver
Published: 2020-01-11 17:13:09


# Flask

```python
from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return "<h1>Hello World!</h1>"

app.run(None, 3001, True)
```

# Express

```javascript
const express = require('express');

const app = express();

app.get('/', (req, res) => {
    return res.send('<h1>Hello World!</h1>');
});

app.listen(3000);
```
Difference between shallow copy and deep copy
Tags: copy, shallow, deep, python
Published: 2020-01-11 17:10:21

# Shallow copy

Shallow Copy points to the same location in memory as 'Source' does. Which essentially means any changes made to the copied item, it will modify the source item as well. ❌

# Deep copy

In deep copy it first creates a new object and then recursively populates it with copies of the child objects found in the original. In case of deep copy, a copy of object is copied in other object. It means that any changes made to a copy of object do not reflect in the original object.✔️

So whenver we do `obj1 = obj`, that's a shallow copy. [in Python and Javascript]
Classes In Python VS Javascript
Tags: javascript, python, class
Published: 2020-01-11 17:06:29

# Python:

```python
class Person:
    def __init__(self, fname):
        self.firstname = fname


class User(Person):
    def createPost(self):
        print('Post created by', self.firstname)
```


# Javascript:

```javascript
class Person {
    constructor(fname) {
        this.firstName = fname;
    }
}

class User extends Person {
    createPost() {
        console.log('Post created by', this.firstName);
    }
}
```
Javascript: Don't miss to put a var/let/const keyword before a variable declaration
Tags: javascript, var, let, const
Published: 2020-01-11 17:02:31

If you miss putting a `var`/`let`/`const` keyword before a variable declaration, it becomes global and gets bind to the global object.

# Usecase:

```javascript
function getName() {
  myVariable = 'shub'
  return myVariable;
}

getName()
console.log(myVariable) // shub
```

`myVariable` will become global and will be accessible everywhere in the program
New in RxJS v7: concatWith operator
Tags: rxjs, angular
Published: 2020-01-11 16:25:24

This post was originally published on [my blog](https://dzhavat.github.io/2020/01/11/new-in-rxjs-v7-concatwith-operator.html).

---

[RxJS v7-alpha.1](https://github.com/ReactiveX/rxjs/blob/master/CHANGELOG.md#700-alpha1-2019-12-27) was released a couple of weeks ago and while it’s exciting to see v7 slowing coming along, this release came with only one new feature. It’s an operator called `concatWith`.

In this short post I’m going to show you how this operator works.

Unfortunately the only available documentation about `concatWith` right now is in the [source code](https://github.com/ReactiveX/rxjs/blob/master/src/internal/operators/concatWith.ts). Here’s how it works:

> Emits all of the values from the source observable, then, once it completes, subscribes to each observable source provided, one at a time, emitting all of their values, and not subscribing to the next one until it completes.

Let’s translate this to a simple example ([StackBlitz](https://stackblitz.com/edit/rxjs-cqhd42)):

```ts
import { of } from 'rxjs';
import { concatWith } from 'rxjs/operators';

const source = of('RxJS', 'is').pipe(concatWith(of('awesome!')));

source.subscribe(x => console.log(x));

// Output:
// RxJS
// is
// awesome!
```

If you’ve used the [`concat`](https://rxjs.dev/api/operators/concat) operator before this might look somehow familiar to you. This is not a coincidence. `concatWith` is actually not a completely new operator. It’s only meant to replace the `concat` operator which is currently marked as **deprecated** and **will be removed in v8**.

There’s one subtle difference between the two, though. `concatWith` **only accepts** inputs of type [`ObservableInput`](https://rxjs.dev/api/index/type-alias/ObservableInput), whereas `concat` can also take a scheduler.

If you want to schedule the observable provided to `concatWith`, you need pass it to the [scheduled](https://rxjs.dev/api/index/function/scheduled) function and also specify a scheduler. ([StackBlitz](https://stackblitz.com/edit/rxjs-vqcyun))

Hope you learned something new. Happy RxJS-ing!

---

Thanks to [Jan-Niklas Wortmann](https://twitter.com/niklas_wortmann) and [Lars Gyrup Brink Nielsen](https://twitter.com/LayZeeDK) for the review.
Practices of the Python Pro out now!
Tags: python, showdev, codequality, books
Published: 2020-01-11 17:02:05

---
title: Practices of the Python Pro out now!
published: true
description: Practices of the Python Pro by Dane Hillard is now available through Manning Books. Learn how to develop more maintainable Python code with separation of concerns, abstraction, composition, and loose coupling.
tags: python,showdev,codequality,books
cover_image: https://thepracticaldev.s3.amazonaws.com/i/hslljuulsoyrli98gky6.png
---

Nearly a year ago I announced that I was writing a book about writing Python code.

{% link https://dev.to/easyaspython/im-writing-code-like-a-pro-software-development-in-python-39ji %}

_Practices of the Python Pro_ is [now available](https://thepythonpro.com)! Holding the physical copy in my hand for the first time was a wild experience. It didn't quite become real until that moment.

I set out to fill what I saw as a learning gap for many people entering the software development space today. Some of my friends were either self-taught programmers who owned their own businesses, trying to pick up programming for use with their existing career, or trying to switch careers into software. The diversity of ways people are getting into and using software is growing so fast!

Even as someone with a traditional path into software development, I didn't learn many of the principles in school that lead to more maintainable code. Learning how to separate concerns, use composition over inheritance, and create more extensible code with approaches like plugin-based architecture all happened "in the field" for me. For those with even less exposure to this stuff, it can be hard to even know these options are out there.

_Practices of the Python Pro_ seeks to give an introduction to many of these principles, building a small project that takes advantage of them along the way. My hope is that it demonstrates the values of maintainable code enough to excite you to keep researching and learning more on your own for years to come.

I learned a lot myself in writing this book. Taking what I already knew theoretically and forcing myself to apply it practically to teach others about it was a great way to find gaps in my own knowledge and realize my inexperience in some areas. I think that's the value of writing and the value of platforms like DEV where people can safely explore and discuss ideas with others. Thanks to all of you for such a lovely space in this corner of the web!
Move self-hosted Octopus Deploy to Cloud
Tags: cicd
Published: 2020-01-12 20:13:53

---
title: Move self-hosted Octopus Deploy to Cloud
published: true
date: 2020-01-11 17:00:00 UTC
tags: CI/CD
canonical_url: https://christophweigert.com/move-octopus-self-hosted-to-octopus-cloud/
---

 ![Move self-hosted Octopus Deploy to Cloud](https://christophweigert.com/content/images/2020/01/Octopus_Logo_2Lines.svg)

After running Octopus Deploy server on our dedicated hardware behind our corporate firewall, we had some limitations with the upload bandwidth, and we wanted to avoid managing the server ourselves. We know that we would have to increase the Tentacles because, in one project, most customers require the software to run on their dedicated hardware. So we decided to migrate to the Octopus Deploy Cloud Version.

The migration was effortless. Let's start with some statistics:

- 1885 Entries in DeploymentHistory Table
- 3 Projects
- 40403 Events
- Database Size: ~ 1500 MB
- Folder-size: ~ 9.2 GB
- Deployment Targets: 10 Tentacles

You can read the current guidelines for the migration at the [Octopus Deploy documentation](https://octopus.com/docs/octopus-cloud/migrations)  
The process required:

- Backup the Octopus database 
- Backup Artifacts, TaskLogs and Packages folder
- Provide the master data key
- Schedule the migration date
- Upload the Backup to a given website

After the migration, you have to reconfigure your tentacles. Polling tentacles have to be updated with the new server address, and listening tentacles will need to be re-registered. However, it seems like a great idea to convert listening tentacles to polling tentacles to avoid having to open ports in your firewall.

Overall the migration took us less than one business day. We are pretty happy with the result. We had no outage so far, and the Support is super fast in responding to questions.
The 5 most neglected skills of professionals
Tags: business, entrepreneurship, hr
Published: 2020-01-11 16:59:51

---
title: The 5 most neglected skills of professionals
published: true
description: Ability cannot be the only metric with which you use to judge how good you are. Soft skills count too!
tags: business,entrepreneurship,HR
---

I initially wrote this post as “The 5 most neglected skills of web professionals”. I amended it as I thought it would be better if I expanded the scope. So I would try not to restrict this only to web developers, but also to other professional groups. This is really only from personal experience.

Hope you enjoy this post as much as I enjoyed to write it, and a few of us can learn from it.

Being diplomatic

Although there are several soft skills, I believe being diplomatic is very important if not the most important. Don’t anger your boss, and common sense stuff like that. From my experience some workers are full of themselves ( that is their own ego ) and have an opinion on virtually everything. Sometimes it pays just to be quiet. Listen first and then act upon feedback. This is make more preferrable to acting first then thinking second.

Sticking to project time lines

Before coming into coding and especially before working in groups of other professionals I never once had to think about beating the deadline to a project. I hate working under pressure, although I can. What ‘good am I if I cannot? Yet still I would appreciate it better if professionals appreciated that skill much more. I mean it cannot hurt to be a little time conscious.

Growing your skillset

Some might raise eye brows but I think this is important. The skill of introducing new skills into every project is really needed. After all competition is fierce, why be comfortable with what you currently know. Aspire to be more. I certainly do, you should too.

Documentation

I might be wrong here. But most of the workers I have met are not crazy about doing paper work. They just want to sit infront of their laptops and work. This is all wrong. Personally, I have realized the need to have a trail of paper on your work. It leads to a longer life span for your work which can only be good for you in the long run.

Inspiration

Sometimes it is difficult to come up with new ways to improve upon your work. And before you know it you have reverted to the old way of doing things. Be creative. Take a walk, research , just have a different outlook on life to bring out that unique product for your client and your workspace.

That’s all. I hope this post touched someone. Thanks again and keep learning.
Javascript Object.keys( ) method
Tags: python, objectkeys, method
Published: 2020-01-11 16:57:47


Want to get all keys present in an object?

> Try `Object.keys( )`

# Usecase:

```javascript
let obj = {
    year: 2019,
    month: 'september'
}

const objKeys = Object.keys(obj);            

console.log(objKeys);

// [ 'year', 'month' ]

```
Object looping in Python vs Javascript
Tags: python, javascript, object, objectlooping
Published: 2020-01-11 16:52:35

# Python
```python
obj = {
    'name': 'Victor'
}

for key in obj:
    print("key: %s, value: %s" % (key, obj[key]))
```

__________

# Javascript:

```javascript
let obj = {
    name: 'Victor'
}

for (key in obj) {
    console.log(`Key: ${key}, value: ${obj[key]}`);
}
```
Busy? Try Todoist
Tags: watercooler, productivity
Published: 2020-01-11 16:05:05



![img](https://cdn-images-1.medium.com/max/1600/1*P7HNFq_jjtHMzOxJiz72vQ.png)*Source: doist.com*

This is a weird post because it’s sort of an app promotion but I’m not being paid for it. Either way, I think this app deserves a little bit of attention.

Everyone needs a to-do list. Keep in mind that this is coming from a person who’s pretty flexible when it comes to task completion. For a long time, I rarely ever used to-do lists because I was usually pretty good at remembering what I had to do. As time went on, however, I needed a better way to keep track of things. So, naturally, I turned to software. That’s when I found [Todoist](https://todoist.com/), a simple app for keeping track of things.

The reason I’m promoting this app and not others is because it’s free(ish) and it has a nice interface that allows for me to keep track of the specific tasks I have to do. Additionally, I use the app to keep track of project ideas that I want to try out over the weekend since I usually don’t get time to experiment on the weekdays. The app allows me to plan out what I have to do today, tomorrow, and for the next week, which is extremely useful since some to-do list apps are only useful for planning what you want to do on that day. As you add and complete tasks, Todoist measures your progress by providing daily summary reports of the number of tasks you are completing, which other apps don’t do. Speaking of completing tasks, the final — and perhaps best — aspect of the app is that it “rewards” you for completing tasks. Todoist has a feature called “karma” where you earn points for completing more tasks. By gaining a certain number of points, you go to a different level. This feature makes Todoist quite good for productivity, and motivates me to complete the pending — and often boring — tasks that I have to complete in a day.

Of course, every app has a downside. Todoist operates on a *freemium* model, meaning that certain features like weekly summary reports and labels, are not accessible if you don’t upgrade to their premium version. The biggest problem with this app is that **reminders are a premium feature**. I usually don’t need reminders to complete tasks, I just need to remember what they are, so this isn’t a problem for me. However, if you need reminders, then maybe upgrading to the premium version or getting a different app would be a good choice.

Thoughts? Opinions? Concerns? Leave a comment below! 😀
A late new year resolution; use my professional skills to help others
Tags: social, community, networking
Published: 2020-01-11 16:01:03

A little while ago a friend told me about a norwegian foundation that in my opinion totally changed the way I see charity work. She, a skilled business developer and project manager had just became part of the foundation. [The Prospera foundation](https://prosperastiftelsen.no/english/) has created a network of consultants and professionals that do pro bono publico work for nonprofits and social change organizations. Donating time and skill. 

This concept of bringing together motivated professionals to help solve social, economic and environmental problems is awesome! Through Prospera, social entrepreneurs and nonprofit organizations can apply for help in law, business development, finance, organizational development, public relations and communications and coaching. 

Even tho their focus isn't technology I believe that technology can be a huge help in finding good sustainable solutions - and be key ingredient for solving some of the issues our society faces. Current and future ones. 

I've applied to see if I can be part of their network and hopefully I have a skill set they find useful and complimentary to what they have and need.

![Prospera web screenshot](https://thepracticaldev.s3.amazonaws.com/i/k6b8pvewmxebp9y3afrs.png)
At the time of this screenshot Prospera has donated professional services worth more than  43,5 million norwegian kroner. That is about 4.9 million USD.
How to Integrate dotenv with NestJS and TypeORM
Tags: webdev
Published: 2020-01-11 15:49:21

<H2>Dotenv integration with NestJS and TypeORM.</H2>

While using third party sources in application development, there must be some involvement of SSH keys or API credentials. This becomes a problem when a project is handled by a team of developers. Thus, the source code has to be pushed to git repositories periodically. Once the code is pushed to a repository, anyone can see it with the third-party keys.

A very prominent and widely used solution for this problem is using environment variables. These are the local variables containing some useful information like API keys and are made available to the application or project.

A tool known as <a href="https://www.npmjs.com/package/dotenv">dotenv</a> has made it easy to create such variables and making these variables available to the application. It is an easy to use tool which can be added to your project by using any package manager.

We will use yarn as a package manager.

First, add the package using terminal.

<I>yarn add dotenv</I>

Since we are using NestJS which is based on typescript, so we need to add the “@types” package for the same that acts as an interface between javascript and typescript package.

 <I>yarn add @types/dotenv</I>
 
Since the database to be used is Postgres, so install the necessary driver for Postgres.

<I>yarn add pg</I>
 
Now install the TypeORM module to your nest project.

<a href="https://codersera.com/blog/how-to-integrate-dotenv-with-nestjs-and-typeorm/">Dotenv integration with NestJS and TypeORM</a>
Is it safe to use let or const in a <script> tag without a bundler?
Tags: discuss, javascript
Published: 2020-01-11 15:35:39

I find that running `let i = 1` two times in a row throws an error, whether it is inside the `<script>` tag or `index.js`, that is not covered by `function() {}`

So, this throws an error,

`index.html`

```html
<script src="index.js"></script>
<script>
let i = 1
</script>
```

`index.js`

```js
let i = 1
```

Actually, I have tried `parcel.js` and it auto-converts `let` to `var` even in raw `<script>` tags...