teleren/devto huggingface dataset:
How Can I Convert EML files to PST with EML to PST Converter Online
Tags: emltopst, emltopstconverter, convertemltopst
Published: 2020-11-27 12:41:28

If you want to Convert your all EML files from Windows Live Mail to Outlook PST then you are at very right place because I'm here to suggest you this best EML to PST converter to Convert complete EML database from Windows Live Mail to Outlook PST. By using this Microsoft EML to PST Converter tool you can easily Convert your all EML file data to Outlook PST in one go.  It allow you to select folder full of convertible EML files and Convert all the EML files to Outlook PST at once. 

EML to PST Converter online gives the complete EML files preview. It show the preview of all Convertible EML files at software interface and allow you to check the desired emails by manually that boost your confidence about EML to PST conversion.  It maintain the data integrity of EML files and will not change anything in the formatting. 

It allow the user to save converted EML file to new PST file as well as existing PST file. It enable the users to Split Outlook PST file into several's parts of manageable PST.  All users both technical or non technical can easily use this software without have any technical understanding. I would suggest you to use it free demo version first to understand it features and functions.

Download this Software free trial version from here: https://www.filesrecoverytools.com/eml-to-pst-converter.html
Starting with TypeScript via JSDoc
Tags: typescript, jsdoc, javascript, webdev
Published: 2020-11-27 12:32:07

In this post it is all about a very interesting technique to use the typing definition of TypeScript without doing a full buy-in for TypeScript.

## JSDoc

> JSDoc 3 is an API documentation generator for JavaScript[...]
> -- <cite>[JSDoc](https://jsdoc.app/about-getting-started.html)</cite>

So most probably you are already using JSDoc for documenting your code. If you don't, you should definitely do!

### JSDoc Typedefs

You might also know that JSDoc provides a way to declare [custom types via the @ŧypedef keyword](https://jsdoc.app/tags-typedef.html).

So we could get something like this:

```js
/**
 * A number, or a string containing a number.
 * @typedef {(number|string)} NumberLike
 */

/**
 * @type NumberLike
 */
const number = 2;
```

But you might not know that you can also import type definitions within the curly braces of the `@typedef` rule, did you? I also didn't...

## TypeScript

That is where [TypeScript](https://www.typescriptlang.org) comes into play:

Example:

File: `typings.ts`

```ts
export type Car = {
  manufacturer: string;
  series: string;
};
```

With this we simply importing those TS-based type definitions as a JSDoc type definition:

File: `foo.js`

```js
/**
 * @typedef {import("./typings").Car} Car
 */

/**
 * @type {Car}
 */
const porsche911Carrera4S = { manufacturer: 'Porsche', series: 'Porsche 993' };
```

I have also created a small [Github Gist](https://gist.github.com/andi1984/e9e73015ad672f036b4562fecc1e0747) where you can see all code at a glance.

## Benefits

Let us be honest... The shown solution here is a trade-off between having no typed language at all or having a 100% TypeScript codebase. Thus this approach will never be as sophisticated as a 100% TS approach, but definitely better in terms of linting, autocompletion and type hints in VSCode as you would have with a plain JS file.

In case you have a huge, complex project with a team behind and you want to dig into type definitions to get some better feeling, understanding and experience with TypeScript, this approach might help you to start getting your fingers dirty.

## Book Recommendation

As you seem to be interested in TypeScript I would like to recommend you a newly released book written by [Stefan Baumgartner](https://fettblog.eu) called ["TypeScript in 50 lessons"](https://www.smashingmagazine.com/printed-books/typescript-in-50-lessons/). But also his blog [https://fettblog.eu](https://fettblog.eu) is an amazing source of TypeScript lessons. Check it out!

Cheers,

Andi
Would you rather work in an MNC or a startup?
Tags: watercooler, career, healthydebate
Published: 2020-11-27 12:40:42

---
title: Would you rather work in an MNC or a startup?
published: true
description: MNCs vs startups
tags: watercooler, career, healthydebate 
//cover_image: https://direct_url_to_image.jpg
---

 👋 dev community,

There is often an ongoing debate about working in startups vs working in MNCs.

Most people prefer to go into MNCs like FAANG for the recognition, perks and the money. 

However, there is a large number of people who prefer to work in a more fast paced environment like a startup with it is high risk and high reward.

I got a chance to intern in a startup when I was in college and since then have been part of an MNC post graduation. I like both for its perks and haven't found anything that I particularly dislike in either. 😅

Where do you stand on this debate?

What do you prefer and why?

What would you suggest someone to choose who is just starting out in their career? 😇
The Quick Comparison on Name Casing
Tags: programming, beginners
Published: 2020-11-27 12:30:52

---
title: The Quick Comparison on Name Casing
published: true
description: There are a number of practices, which I'll cover in quick fashion here, to name variables and other objects when programming.
tags: #programming #beginners
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/vm67dgt0l1mp17fm1ihd.jpg
---
There are a number of name casing practices, which I'll cover in quick fashion here, for variables and other objects when programming.

## The Quickie Synopsis

* camelCaseLikeThis
* PascalCaseLikeThis
* snake_case_like_this
* kebab-case-like-this
* MixAnd-match_like-this

## Camel Case

With Camel Case the first letter of the first word is lower case, then every subsequent first letter of each word is upper cased. For example, `thisIsCamelCased`, `something` if a singular word, or `somethingElse`.

> My 2 ¢ - I'm a big fan of this case when I'm name private variables or related objects. I'm also a fan of using Camel Casing for certain types of functions, especially in JavaScript such as `this.doesStuff()` or `somethingAnother.doesOtherStuff()`.

## Pascal Case

In usage of Pascal Case, the first letter of each word within the name is upper cased. Examples include `ThisOject`, `ThatThing`, or `WhateverElse()`.

> My 2 ¢ - This is something I like to use for class declaracters (i.e. public class ThisClassThing) and then for functions or methods on that class, or respectively similarly for functions on functions in JavaScript, or the like. Basically, anything that will be used similar to `MyThing.DoesThisThing()`.

## Snake Case

Using Snake Case has the empty spaces replaced with underscores. So a file name like `this is my filename.md` would become `this_is_my_filename.md`.

> My 2 ¢ - Snake case is great when I need to have variables that would otherwise have spaces, but also wouldn't be displayed regularly with anything that might obfuscate the underscore, such as an HTML.

## Kebab Case

Kebabs are tasty, the case however is similar to Snake Case, except instead of underscores dashes are used. Each space in the name is replaced with a `-` character. Such as `my-table-name-is-this` or `this-is-a-variable`.

> My 2 ¢ - Kebab case is excellent for filenames, URIs, or something of that sort where spacing between the words of a file or path are important to read, but an underscore would be obfuscated by the font rendering such as with a URI.
I created a tool to manage VSCode settings on GitHub
Tags: vscode, github, git, bash
Published: 2020-11-27 12:05:34

I created a tool to manage Visual Studio Code settings on GitHub(Git).
https://github.com/otashun/vscode-settings

## Getting started
```
git clone git@github.com:otashun/vscode-settings.git
cd vscode-settings
./install.sh
```
How to Crack the Google Cloud Professional Data Engineer Exam in 1 Month (December 2020)
Tags: googlecloud, cloud, programming
Published: 2020-11-27 12:00:28

The Whats and Whys of the Certification

For any exam you take, a fundamental understanding of the Certification and what it is for is essential to increase your chances of acing it. In Google’s own words, the Data Engineering Certification is to Read More : https://lnkd.in/eKRC2EJ


More Update :

Telegram : https://t.me/codetrophs

Medium : https://codetrophs.medium.com/

Dev : https://dev.to/codetrophs

Twitter : https://twitter.com/CodeTrophs


#datascience #data #python #machinelearning #dataengineering #bigdata #analytics #cloud #cloud #google #engineer #devops #gcpcloud
structure synth [Nabla]
Tags: codepen
Published: 2020-11-27 11:55:21

---
title: structure synth [Nabla]
published: true
tags: codepen
---

<p>This is my webGL version of the structureSynth "Nabla.es" Eisenscript by Mikael Hvidtfeldt Christensen, Oct 1, 2008</p>

<p><a href="https://www.flickr.com/photos/syntopia/2904900833/" target="_blank">https://www.flickr.com/photos/syntopia/2904900833/</a></p>

<p><a href="http://structuresynth.sourceforge.net/index.php" target="_blank">http://structuresynth.sourceforge.net/index.php</a></p>

<p>Click to generate new structures</p>

{% codepen https://codepen.io/ge1doot/pen/abmbZaX %}
Java finalize() is danger
Tags: java, finalize, jvm, 100daysofcode
Published: 2020-11-27 11:51:13

In every Java object, there is a method called **finalize()**. You can override this method in any of your classes. The purpose of this method was to implement clean-up codes. When the object is garbage collected by the garbage collector, the garbage collector will invoke this method.

But no one can ensure whether the garbage collector will get a chance to invoke that method. Because we can't force to run the garbage collector even by calling **System.GC()**. 

Refer to the following code.

```java
public class Demo{
  private DBConnection dbcon;

  public Demo(DBConnection con){
    this.dbcon = con;
  }

  @Override
  finalize(){
    this.dbcon.close();
  }

  public static void main(String[] args){
    for(int i = 0; i < 1000000; i++){
       Demo demo = new Demo(
         new DBConnection("credentials")
       );
    }
  }
}
```

A million database connections will be opened when we run this code, but the connection closing logic is implemented inside the **finalize** method. Since no one can ensure that the garbage collector will trigger before the application ends, a million database connections may be wasted. 

So it is not recommended to override the **finalize** method. Especially when you want to implement a critical piece of code inside the finalize method.

Because of this, Java has deprecated the **finalize** method from version 9. But still, if you want to do this, there are few workarounds that you can take.

## 1. Register a shutdownhook

You can use **shutdownhook** to execute things like resource cleanups, closing log files, etc. Shutdownhook will be executed by the JVM before shutting down the JVM. You can register as many as **shutdownhooks** you want and those will be executed concurrently, and you can't tell what order it will be executed. 

## 2. Using PhamtomReference

`A phantom reference is a kind of reference in Java, where the memory can be reclaimed. The phantom reference is one of the strengths or levels of 'non-strong' reference defined in the Java programming language; the others being weak and soft.`

This is the same definition from Wikipedia about the phantom reference in Java. I have no much clarity about phantom reference. Maybe I will explain this will in another article. 
Until that https://www.baeldung.com/java-phantom-reference will help you ;).
How do you manage browser bookmarks/sessions?
Tags: discuss
Published: 2020-11-27 11:42:00

Closest I've found to an ideal solution is [gettoby](https://gettoby.com). However, no firefox addon yet.

OneTab is nice, but I've lost my sessions too many times.  Those need to be persisted for sure.

How do you manage your browser sessions?  With bookmarks?
Have you built any projects with Electron?
Tags: watercooler, javascript, electron, desktop
Published: 2020-11-27 11:40:35

---
title: Have you built any projects with Electron?
published: true
description: 
tags: watercooler, javascript, electron, desktop 
cover_image: https://1.bp.blogspot.com/-lAHE9MSWXjY/Wmh6GKyK03I/AAAAAAAAvjw/yZkRCMTLbIcWNiNKzpuO_E5-6lhbJphfACLcBGAs/s728-e100/electron-js-framework-hacking.png
---
Thanks to [Electron](https://www.electronjs.org/) you can build cross-platform desktop apps with JavaScript, HTML, and CSS. It's an [open-source](https://github.com/electron/electron) project, that uses Chromium and Node.js and is actively maintained by GitHub.

It's been in my eye for a while, so I'm curious have you built any projects with it, and what was your experience?
Introduction to Simply Responsive Design
Tags: ux, design, flutter
Published: 2020-11-27 11:31:35

There are a lot of device screen sizes right now. While it's mostly a good thing to give users options, we, as developer (and designer) often suffers (lol) because we need to support those different screen sizes.

There is a popular choice in the 12 grid system in the web development world. But in the app development world, 12 grid responsive system also not that popular (wonder why).

The example of this is the iphone and ipad app. There are quite a lot "ipad" apps out there when downloaded, only displays the layout in the cropped "iphone" view, which is sucks.

###Enter the Simply Responsive Design.

Simply Responsive Design is a term I coined (what a creative name right?) myself. This design system derives / inspired from Material Design mostly, and I build it in the context of me, as a flutter developer.

Unlike the 12 grid system, a Simply Responsive Design (or SRD), only assumes there are 3 maximum columns on the screen, along with fixed top and bottom bar / app bar. This simplification has both advantage and disadvantage. Basically, SRD trades flexibility for development speed.

SRD has 3 kind of screen sizes in mind:

1. Mobile (< 600px width)
![SRD Mobile](https://dev-to-uploads.s3.amazonaws.com/i/ac3m6jg8qp4sld7v7dkb.jpg)

2. Tablet (600 - 767px width)
![SRD Tablet](https://dev-to-uploads.s3.amazonaws.com/i/s60t5fug9if4r6gkvdnu.jpg)

3. Desktop (>= 768px width)
![SRD Desktop](https://dev-to-uploads.s3.amazonaws.com/i/k44vepyzcfscbtxkw9m4.jpg)

As you can see, the UI (or widgets in flutter) placements, are kinda predictable across screen sizes. This makes your development speed faster and easy, if in the beginning of a project, you already make a custom scaffold to abstract out the logic. This way, it will be much easier for subsequent codes to be responsive out of the box.

```
/// Prototype of SRD as an abstracted out flutter widget
return SimplyResponsiveScaffold(
  title: 'MyTitle'
  leftContents: <Widget>[],
  centerContents: <Widget>[],
  rightContents: <Widget>[],
);
```

With that widget, no matter what screen size your app is running on, The `SimplyResponsiveScaffold` will automatically determines where your left, or center, or right should be placed based on the screen size.

(This also make your app works automatically when rotated)

=====

That's it for the introduction part of Simply Responsive Design. In the future articles, I'm going add in-depth explanation of UI elements interactions SRD. I also plan to write a custom flutter library to make it easier to implement SRD.

Thank you and see you in the next article!
What are your favorite coding related books?
Tags: watercooler, coding, programming, books
Published: 2020-11-27 11:28:05

---
title: What are your favorite coding related books?
published: true
description: 
tags: watercooler, coding, programming, books
cover_image: https://hackr.io/blog/best-programming-books/thumbnail/large
---
What are your favorites books (preferably online and for free) from general programming concepts and paradigms to specific languages?

I'm pretty focused on the JS ecosystem and my favorites are [Eloquent Javascript](https://eloquentjavascript.net/), [You don't know JS](https://github.com/getify/You-Dont-Know-JS/blob/1st-ed/README.md), and [Javascript.info](https://javascript.info/). All of them are free.
Molasses is Live on Product Hunt!
Tags: webdev, producthunt, showdev, node
Published: 2020-11-27 11:17:13

[Molasses is launching on Product Hunt Today!](https://www.producthunt.com/posts/molasses-feature-flags-as-a-service)

208 times more often.

According to the latest State of the DevOps report, high performing teams deploy code 208 times more often than a low performing team. While actually having fewer bugs. More deployments?! Less bugs?! 

When I read that I was shook. So I decided to help teams faster and ship code with fewer bugs by launching Molasses! 

Molasses is a feature flag platform. Feature flags are a technique that allows you to turn on or off features without having to deploy new code, allowing you to release code more often. Molasses supports many different languages and frameworks - React, React Native, TypeScript, JS, Node, Go, Python, and Ruby. 

Once you use tools like this you realize how important it is to have powerful tooling around it. So I also included audit logging and an integration with Slack.

I'm excited for folks to try Molasses. If you are looking to give it a test run, let me know and I can help you get started right away. Check out our [website](https://molasses.app/), our [github](https://github.com/molassesapp/) and of course our [Product Hunt Page!](https://www.producthunt.com/posts/molasses-feature-flags-as-a-service)
How to run queries in a transaction on nest.js with TypeORM
Tags: typescript, node
Published: 2020-11-27 11:15:55

When we use nest.js in TypeORM app, we may use Repository<Entity> in Service modules.
But, how about transactions? I found an easy way to do it.

```typescript
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

import { FooService } from './foo.service';

//TODO: import Foo and Bar entities.

@Module({
  imports: [TypeOrmModule.forFeature([Foo, Bar])],
  providers: [SurveysService],
  // TBD: controllers: [FooController],
})
export class FooModule {}
```

```ts
import { InjectRepository } from '@nestjs/typeorm';
import { Connection, Repository } from 'typeorm';

//TODO: import Foo and Bar entities.

@Injectable()
export class FooService {
  constructor(
    private connection: Connection
  ) {}
  async doAwesome(): Promise<void> {
    await this.connection.transaction(async manager => {
      const fooRepository = manager.getRepository<Foo>('foo');
      const barRepository = manager.getRepository<Bar>('bar');
      await fooRepository.updateSomething();
      await barRepository.deleteSomething();
    }
  }
}

// NOTE: Of course, you need to add `TypeOrmModule.forRoot` with foo and bar entities as nest.js the document says.
```
#DevHack: Optimizing initial load JS from Next.js
Tags: typescript, webdev, react, javascript
Published: 2020-11-27 11:01:20

Now that my [PimpYourOwnBike](https://pimpyourownbike.com) website has launched. I started looking at where I can do some optimizations. When looking at the Next.js build output, I spotted a red number in the **First Load JS** section.

![First load JS too big](https://www.eliostruyf.com/uploads/2020/11/firstload1.png)

That would be the first thing on my list to optimize, getting this number from red to green.

## What is this `First Load JS`?

First of all, what is this `First Load JS` exactly? The documentation specifies that the value is based on the number of assets downloaded when visiting the server's page. The amount of JS shared by all is shown as a separate metric.

To make it simpler to understand, it is all the JS your website requires to start rendering your content. To get this first load JS number down, you have to write less code.

> **Info**: `<===>`

Ok, that is not entirely true and might be very hard to achieve, but you need to get the bundle/chunk sizes down.

## How to lower the first load JS size?

### Use fewer dependencies

Check through your code if you have dependencies you might be referencing that are not required anymore.

I know this is what most articles you find will tell this. The reason is that it is very effective, but not easy to achieve. In many cases, you need all these dependencies.

### Lazy/dynamic loading components and dependencies

If you need all these dependencies, check what can be lazy or dynamically loaded. This approach means that you will load all the initial components on the page and asynchronously load all the less critical others, or they do not matter if they are loaded later.

The good thing about this approach is that it works both for React components for dependencies you want to use.

When using React, you typically use `React.lazy`, but this will not work if you are using Server-Side Rendering with Next.js. Luckily, there is a Next.js dependency called `dynamic`, which does the same thing.

> **Info**: [Dynamic import Next.js documentation](https://nextjs.org/docs/advanced-features/dynamic-import)

```typescript
import dynamic from 'next/dynamic';

// Loading StickerForm component, showing spinner while fetching the component
// Use it like you're use to <StickerForm />
const StickerForm = dynamic(() => import('./StickerForm'), { loading: () => <Spinner /> });
```

Above, you see an example of how I load my form on the site. By only implementing this dynamic import, I got my first load JS size down to 89kB.

![First load JS optimized](https://www.eliostruyf.com/uploads/2020/11/firstload2.png)

From project to project, it might be hard to achieve the same optimizations. So try to find these components or libraries, which are not instantly required for your page. For instance, this could be used for components that are, by default, loaded below the fold.

*Happy coding*

First published on: [https://www.eliostruyf.com/devhack-optimizing-initial-load-js-nextjs/](https://www.eliostruyf.com/devhack-optimizing-initial-load-js-nextjs/)
Deploy Oracle Cloud Compute Instance, configure Nginx with TLS on GitHub Actions using Terraform and Ansible for free
Tags: terraform, ansible, oraclecloud, github
Published: 2020-11-27 11:00:58

# Intro

This is an article which describes how to provision a free [Oracle Cloud Compute Instance](https://www.oracle.com/cloud/compute/) from [GitHub Actions](https://github.com/features/actions) using [terraform](https://www.terraform.io), configure [Nginx](https://www.nginx.com) and generate [LetsEncrypt](https://letsencrypt.org) SSL certificates for a free dynamic domain from [DuckDNS](https://www.duckdns.org) and deploy a simple [NodeJS](https://nodejs.org/en/) app on that instance.

## Prerequisites