teleren/devto huggingface dataset:
How to get Consolidated Realised Gain Statement
Tags: howto, assetmanagementcom, cams, consolidatedrealise
Published: 2018-10-11 07:15:28

---
title: How to get Consolidated Realised Gain Statement
published: true
tags: How To,Asset Management Com,CAMS,Consolidated Realise
canonical_url: 
---

A Consolidated Realized Gain Statement (CRG) contains the Gain or Loss details of Mutual Fund Investments. It is very simple to obtain from CAMS. This article will detail about how to obtain CRG statement from CAMS and explain the statement in detail.

The post [How to get Consolidated Realised Gain Statement](https://mfrepublic.com/obtain-consolidated-realised-gain-statement/) appeared first on [MF Republic](https://mfrepublic.com).
How fast is your code?
Tags: javascript, webdev, node, showdev
Published: 2018-10-04 22:49:15

---
title: How fast is your code?
published: true
description: 
tags: javascript, webdev, node, showdev
cover_image: https://thepracticaldev.s3.amazonaws.com/i/vwvcv2dojmteag23vokn.png
---
One of the key metrics when writing code is speed. But there is no convenient way to measure the speed of your code efficiently so far. Chrome and other browsers do have APIs (`new Date()`, `performance.now()`, `console.time`) that let you put them around your code, then you will do a simple calculation to find out the diff, like: `t2 - t1`

### Another Approach

That works for an instant need when you want to know how much time a block of code executes. However, when you want to do more, you will have to write some util functions or library.

`Performance.now()` is a high resolution timer API that you can rely on to measure time difference. Many modules were created to utilize that API, one of them is mstime - https://github.com/ngduc/mstime - a lightweight module (2 KB gzip) to measure and visualize code performance in (ms).

### Usage

Now with the help of the `mstime` module, you can write simple code like this:
```JS
mstime.start("codeblock1");
myFunction();
console.log( mstime.end("codeblock1") );
```

Nothing is new so far. Until you take a closer look a the output:

```
{
  entries: [
    { start: 41991120.53, end: 41991133.04, diff: 12.50 }
  ],
  plugins: { ... },
  last: 12.50,
  sum: 12.50,
  avg: 12.50
}
```

That open the door to opportunities! You now have control on the dataset of every measurement, plus useful calculations like: sum, average (avg), last value & a plugin system!

There are a couple of built-in plugins like: calculating for trimmed mean (e.g. get 90 percentile of data), persisting data to localStorage, plotting data to chart, etc.

[Example](https://rawgit.com/ngduc/mstime/master/docs/demo/index.html) of using the chartist plugin to plot time data:

![chartist plugin](https://github.com/ngduc/mstime/raw/master/docs/screenshot-01.png)

Now it's your turn to utilize the dataset you captured!
Please comment below, let me know your ideas, feedbacks or anything you like to discuss.
ng-hcaptcha - An easy-to-use hCaptcha component for Angular 6+
Tags: hcaptcha, angular, nghcaptcha, captcha
Published: 2018-10-04 22:16:04

---
title: ng-hcaptcha - An easy-to-use hCaptcha component for Angular 6+
published: true
description: If you don't know about hCaptcha, check it out at hcaptcha.com!
tags: hcaptcha, angular, ng-hcaptcha, captcha
---
A higher-level Go reflection package
Tags: go, webassembly, devlog
Published: 2018-10-04 21:54:32

---
title: A higher-level Go reflection package
published: true
description: Today I started a pretty simple Go library that wraps the builtin reflect package and gives you a simpler API modeled after syscall/js.
tags: Golang, WebAssembly, devlog
---

Yesterday I did a quick, unscheduled stream to start a Go package that provides a simpler reflection API for Go values. Go has a reflect package that's pretty great, but doing basic things like calling a method or getting a property isn't as trivial as it could be. Plus the nature of reflection means this usually takes a lot of experimentation to get right. At least for me, and I've worked with Go reflection quite a bit. 

The idea was to provide an API that looks more like the syscall/js API, which is used for interacting with JavaScript values of WebAssembly hosts. Besides being simpler, this API has methods for getting and setting properties and calling methods. These are some of the most common operations in reflection, but using reflect by itself doesn't just give you these. 

So that's all this is. A simple higher level wrapper for the reflect package. This can be used for more easily making JavaScript proxy objects to Go values in WebAssembly or exposing values over RPC, both of which I expect to be doing. But also, I use reflection a lot and this will save a lot of time remembering how to do some of these basic operations.

Anyway, I got the simple version of the interesting methods done, as well as some basic tests. I might work on this more off stream or as needed in projects that use this.

{% youtube 19azPetfH6o %}
Chapter 2 // Building a Decentralised Blog
Tags: decentralised, personal, blog
Published: 2018-10-04 21:47:13

---
title: Chapter 2 // Building a Decentralised Blog
published: true
description: An update on decentralising the personal blog
tags: #decentralised #personal #blog
cover_image: https://thepracticaldev.s3.amazonaws.com/i/yvrg8cb8p2k9eejvyrmt.jpg
---

Previously: https://dev.to/luke/chapter-1--building-a-decentralised-blog-2n8e

Hey guys and gals. It's been a while!

I went travelling around Asia for a bit, lost myself, found myself, found some great food. It was good.

Anyway, I've just taken a look at where I left my epic challenge to redefine blogging for a decentralised world.

Things are looking good; I've got half a frontend and am on my way to having a personal blog site! The slightly unfortunate news is that I've barely got time to think at the moment as I settle into my new job. But I'm feeling positive and I think I can at least push this to the point where my personal blog (and yours if you so choose) is shiny and ready for decentralisation.

## The Plan

The Plan is to create a fool-proof API for the frontend that will allow anyone to write blog posts and have them rendered beautifully without much thought. This first stage will have reduced functionality:
 - no comments
 - no subscriptions
 - nothing involving the [\[matrix\] protocol](https://matrix.org)

This isn't to say I won't try and make efforts to continue once this first chunk is done, but plans change and it would be nice to leave it in a nice place (if I have to leave it at all).

To repeat my beautiful ascii art:

```
                   (3) 
    journal backend-----[matrix]
      |  |                 |
  (2) |  |         ________| (4)
      |  |        |  
      |  |        |  next.js
  ____|__:________|_________
 |                          |
 | journal web UI frontend  |
 |__________________________|
       | :
   (1) | |(2)
       | |
   web browser
```

Above is the architecture of the finished system.

The plan is to create a reduced functionality "journal backend" that can only:
 - list articles
 - retrieve individual articles
 - somehow expose author details

My current thinking is to have the backend serve a directory structure of articles plus some configuration for the author details.

This set of files will in future be the output of a more complicated backend capable of:
 - scraping the [matrix] federation
 - sending live updates to the frontend

But for now the humble personal blogger will be responsible. 

Naturally this competes directly with dev.to, but I have to say I think dev.to currently provides more functionality.

That's all I've got for now. Follow me for more updates 🚀
Simplify pushing to git
Tags: git, scm, sourcecontrol
Published: 2018-10-04 21:10:48

---
title: Simplify pushing to git
published: true
description: One git config trick that I was missing.
tags: git, scm, source control
---

I think everyone using *git* from command line knows this scenario:

1) Code, code, code, ...
2) Hmm, better save my progress.
```sh
$ git checkout -b myawesomefeature
$ git add .
$ git commit -m 'It works!'
$ git push
fatal: The current branch myawesomefeature has no upstream branch.
To push the current branch and set the remote as upstream, use

    git push --set-upstream origin myawesomefeature
```
3) !@#$%\^&

And then you just have to manually type the lengthy command above to be able to push.

After doing this quite a few times I [found out](https://stackoverflow.com/a/22933955/472284), that there is a better way. You can tell git to automatically set the upstream for you by adjusting following config:

```sh
git config --global push.default current
```

After this, simple `git push` call will push *current* branch to a *remote* branch of the same name. 

But before setting this, it's a good idea to [read the documentation](https://mirrors.edge.kernel.org/pub/software/scm/git/docs/git-config.html) and understand what the different options do:

- current - push the current branch to update a branch with the same name on the receiving end. Works in both central and non-central workflows.
- upstream - push the current branch back to the branch whose changes are usually integrated into the current branch (which is called @{upstream}). This mode only makes sense if you are pushing to the same repository you would normally pull from (i.e. central workflow).
- simple - in centralized workflow, work like upstream with an added safety to refuse to push if the upstream branch’s name is different from the local one.
Big Data, what would be the best software to use?
Tags: mysql, bigdata, documentstorage, mongodb
Published: 2018-10-04 20:53:08

---
title: Big Data, what would be the best software to use?
published: true
description: 
tags: MySQL, big data, document storage, MongoDB
---

Hi everyone,

I know this is a bit far fetched but just wanted to see what other developers have done in the past.

So let’s imagine we have 3 sets of data that are about 300 million rows in each set, ie 3x MySQL tables and each of them hold 300 million rows and let’s say 20 columns of mixed data (varchar and integers).

What’s the best way in theory to collate data from each set and return it to the user under a second? How is it done?

Horizontal scaling?

Hardware and power or is the bigger part really to do with data design and the way you go about retrieving the data?

I would like to know other developers experiences similar to the above and how they overcame any hurdles along the way.

Thanks everyone :)
why did I quit my 6 figure job to found my startup in Tech
Tags: hrtech, recruitment, startup
Published: 2018-10-04 20:52:30

---
title: why did I quit my 6 figure job to found my startup in Tech
published: true
description: 
tags: #HRtech #recruitment #startup
---

https://medium.com/@pierre_vannier/why-i-quit-my-6-figure-job-to-found-my-own-startup-94ed94cd11d
6 books you need to read as a software developer
Tags: books, softwaredeveloper
Published: 2018-10-11 21:17:57

---
title: 6 books you need to read as a software developer
published: true
tags: books,softwaredeveloper
canonical_url: https://howtosurviveasaprogrammer.blogspot.com/2018/10/6-books-you-need-to-read-as-software.html
---

There were some book which changed a bit my way of thinking regarding software development. I think everyone should read these books who have anything to do with programming.

The list is the following:
  
   

1. Robert C. Martin: Clean Code

I read this book shortly after I started to work as a software developer. At my first company it was a big problem, that all code was messy which caused quite a lot of issues. The book changed the way I’m thinking about programming and helped a lot during your carrier. But of course you need to handle it flexible: don’t follow blindly everything what you read.

  

2. Steve McConnel: Code Complete

This book is quite long, but it is covering almost everything what is connected to programming: requirements, debugging, refartoring, configuration management, documentation, integration, development, everthing.
  
   

3. Michael C. Feathers: Working Effectively with Legacy Code

This book was proposed for me by a colleague when we needed to refactor a quite complex old legacy tool. This refactoring was done succesfully, it was strongly decreasing the amount of bugs and it would not happen without this book.
  
   

4. Robert C. Martin: Agile Software Development

This book is much more about processes, but it is partially covering technical topics as well. It gave me a pretty good overview on agile processes. I read it when we started to work based on scrum at my current company and that was my first experience with scrum. It helped me to understand the whole process and gave me a lot of ideas for improvement.
  
 
5. Robert C. Martin: The Clean Coder

It is never enough to talk about code quality. If you liked Clean Code, you need to read this one as well!
  
   

6. Gayle Laakmann: Cracking the coding interview
  

The best book to read before starting job search and attending interviews. I got it a bit late, I read it before the first technical interview I lead at my place, but it was really helpful. I plan to write more about this topic later.

http://howtosurviveasaprogrammer.blogspot.com/
🐛 DEV bugs up for grabs 🐛
Tags: meta, hacktoberfest
Published: 2018-10-04 20:20:04

---
title: 🐛 DEV bugs up for grabs 🐛
published: true
description: For anyone interested in contributing to the DEV Community codebase.
tags: meta, hacktoberfest
---

For anyone interested in contributing to the DEV Community codebase, here are a few bugs that could use some love. One issue is as early as #96! (we're in the 800s now 😱)

If anything is unclear or you need feedback/help please don't hesitate to mention anyone on the [core team](https://github.com/thepracticaldev/dev.to#core-team). 

{% github https://github.com/thepracticaldev/dev.to/issues/96 %}
{% github https://github.com/thepracticaldev/dev.to/issues/208 %}
{% github https://github.com/thepracticaldev/dev.to/issues/253 %}
{% github https://github.com/thepracticaldev/dev.to/issues/525 %}
{% github https://github.com/thepracticaldev/dev.to/issues/424 %}
{% github https://github.com/thepracticaldev/dev.to/issues/640 %}
{% github https://github.com/thepracticaldev/dev.to/issues/625 %}
{% github https://github.com/thepracticaldev/dev.to/issues/735 %}


Happy Coding!
A List of Companies that Hire Jr Devs for Remote Positions
Tags: junior, beginners, career, remote
Published: 2018-10-04 20:17:57

---
title: A List of Companies that Hire Jr Devs for Remote Positions
published: true
description: A list of companies that hire junior developers for remote positions
tags: junior, beginners, career, remote
cover_image: https://images.unsplash.com/photo-1492681290082-e932832941e6
---

A few weeks ago, @isaacandsuch posted a great article about [hiring junior developers](https://dev.to/isaacandsuch/if-you-dont-hire-juniors-you-dont-deserve-seniors-48kb).

The article got me thinking about how _extra_ hard it is for junior developers to find remote work. So I started a [GitHub repo](https://github.com/AdamLombard/we-hire-remote-junior-devs) listing companies that hire junior developers for remote positions.

{% github AdamLombard/we-hire-remote-junior-devs %}

If you know of such a company, please submit a pull request (or message me directly) and I'd be happy to add it to the list!

---

Was this helpful? Did I save you some time?

## {% cta https://www.adamlombard.com/support-me %} 🫖 Buy Me A Tea! ☕️ {% endcta %}

---
Run Flask app as 0.0.0.0
Tags: flask, docker, mvc
Published: 2018-10-04 19:48:51

---
title: Run Flask app as 0.0.0.0
published: true
description: Run Flask app as 0.0.0.0
tags: flask, docker, mvc
---
To access the Flask app from docker container

Step #1
`export FLASK_APP=execute.py`

Step #2
`echo $FLASK_APP `

Step #3
`flask run --host=0.0.0.0`
What Darwin Understood - Classification
Tags: softwaredevelopment, architecture, problemsolving
Published: 2018-10-04 13:52:15

---
title: What Darwin Understood - Classification
published: true
description: Classification and software development
tags: software development, architecture, problem-solving
---
Most likely the name Charles Darwin rings a bell somewhere in your memory – perhaps from your high school biology. He was an English Biologist best known for his theory of natural selection. As a computing professional, I do share an appreciation for his approach to *problem-solving through classification*. I would like to draw similarities between this concept as it relates to software development. **Classification provides a frame of reference and allows us to reason about our applications in a broader sense**. This is exactly what a good software architecture aims for.

 Software architecture is concerned with drawing boundaries and crafting relations among them. In other words, each block of code is carefully be placed within a bounded area. Moreover, these areas are designated based on their problem categorization. So, **in the end, we are really dealing with a categorization problem and providing facilities to address specific sub-problems within those categories**. Important to note here is that other fields, such as Mathematics, tend to have a similar approach whereas problems are addressed through a certain frame of reference. For instance, we can reason through a given problem as an Algebraic problem or Geometric problem and so forth. **A frame of reference guides our decisions based on existing knowledge in that domain and provided facilities in our infrastructure**. 

*A good architecture facilitates greater reusability by providing clean categorization – an abstraction of some sort*. The further apart components are, the less likely they share any reusable code. The opposite can be said for components in close proximity. This is even more so for items placed in a similar category. What does this all mean? *We address the general problem first, therefore providing facilities to describe our specific needs. Thus, categories emerge as more general problems are solved, and patterns are forged*. So what problems are you solving – category? What other problems are you familiar with in that category? Can your problem be framed in a different category? It all boils down to classification and your system should be expressive in terms of the types of problems it addresses.
Python Flask app to run Shell script from web service
Tags: python, flask, mvc, cli
Published: 2018-10-04 19:41:04

---
title: Python Flask app to run Shell script from web service
published: true
description: Python Flask app to run Shell script from web service
tags: python, flask, mvc, cli
---

``` python
from flask import Flask
from flask import request
import subprocess
import shlex
import urllib.parse
app = Flask(__name__)

@app.route("/run/",methods = ['POST', 'GET'])
def execute():
    command = 'no command'
    print("============")
    command = (request.data).decode("utf-8")
    print(command)
    if request.method == 'POST':
        print('Started executing command')
        command = shlex.split(command)
        process = subprocess.Popen(command, stdout = subprocess.PIPE)
        print("Run successfully")
        output, err = process.communicate()
        return output
    return "not executed"

if __name__ == "__main__":
    app.run()

```
Welcome Thread suggestion
Tags: welcome, devto, featurerequest, meta
Published: 2018-10-04 17:59:51

---
title: Welcome Thread suggestion
published: true
description: The welcome thread needs to change its post ordering
tags: welcome, devto, featurerequest, meta
---

Instead of ordering comments in the Welcome Thread by hearts, maybe it's better to order comments either by the least number of views or latest date posted instead. I didn't even realize you had to click on a 'Read More' button or I wouldn't have even seen the other posts.
Developing a RESTful Client with Retrofit and Spring Boot
Tags: springboot, retrofit, java, restfulapi
Published: 2018-10-04 17:39:53

---
title: Developing a RESTful Client with Retrofit and Spring Boot 
published: true
description: Learn how to use Retrofit and Spring Boot to develop a RESTful HTTP client to GitHub's API.
tags: #springboot #retrofit #java #restfulapi
canonical_url: https://auth0.com/blog/developing-a-restful-client-with-retrofit-and-spring-boot/
---

In this article, you will learn how to use Retrofit, an HTTP client library, and Spring Boot to create a client for a RESTful API. You will use Spring Boot and its RestController functionality alongside Retrofit to develop a facade over GitHub's API. You will also learn how to convert JSON to POJOs (Plain Old Java Objects) using Google's Gson library and, last but not least, you will learn how to use the documentation of a RESTful API to your advantage. 

[Read on 🍃](https://auth0.com/blog/developing-a-restful-client-with-retrofit-and-spring-boot/?utm_source=dev&utm_medium=sc&utm_campaign=retrofit_spring)

![Developing a RESTful Client with Retrofit and Spring Boot](https://thepracticaldev.s3.amazonaws.com/i/ynvz5csmrop0c7v6yrqu.png)
Webcamp Zagreb 2018
Tags: wczg, conference, webdev, discuss
Published: 2018-10-04 17:36:00

--- 
title: Webcamp Zagreb 2018
published: true
description: 
tags: wczg, conference, webdev, discuss
---

![Webcamp Zagreb 2018](https://thepracticaldev.s3.amazonaws.com/i/nsicdrmz86bvh5awu341.png)

Is anyone from dev.to besides me going to Webcamp Zagreb tomorrow? :D
Hacktoberfest Open Source Projects using Laravel
Tags: hacktoberfest, opensource, php, laravel
Published: 2018-10-04 17:33:05

---
title: Hacktoberfest Open Source Projects using Laravel 
published: true
description: Looking for open source projects using laravel   
tags: #hacktoberfest #opensource #php #laravel 
---

Fashionably late to the party, but does anyone know of any active open source projects using Laravel, beginner-friendly would be a great bonus.Let me know ! Ones involved with Hacktoberfest would be an even greater bonus !