teleren/devto huggingface dataset:
Telegram isn't really encrypted, but you can easily encrypt chats with this service
Tags: security, telegram
Published: 2020-01-23 04:50:26

Originally published at: http://explorer.testnet.mesg.com/services/cTPFWWc4WULrqdwgXMN8461mGTbowQ1vFiMRGjy2X5V?utm_source=devto&utm_medium=blog&utm_campaign=encryption_service



# Encrypt &amp; Decrypt (ID: encrypt)



## Contents

- [Installation](#Installation)
  - [MESG SDK](#MESG-SDK)
  - [Deploy the Service](#Service)
- [Definitions](#Definitions)
  - [Tasks](#Tasks)
    - [encrypt](#encrypt)
    - [decrypt](#decrypt)
    - [generate](#generate)

## Installation

### MESG SDK

This service requires [MESG SDK](https://github.com/mesg-foundation/engine) to be installed first.

You can install MESG SDK by running the following command or [follow the installation guide](https://docs.mesg.com/guide/start-here/installation.html).

```bash
npm install -g @mesg/cli
```

### Deploy the Service

To deploy this service, go to [this service page](http://explorer.testnet.mesg.com/services/cTPFWWc4WULrqdwgXMN8461mGTbowQ1vFiMRGjy2X5V) on the [MESG Explorer](http://explorer.testnet.mesg.com).

## Definitions


### Tasks

<h4 id="encrypt">encrypt</h4>

Task key: `encrypt`



##### Inputs

| **Name** | **Key** | **Type** | **Description** |
| --- | --- | --- | --- |
| **publicKey** | `publicKey` | `String` |  |
| **data** | `data` | `String` |  |
  
##### Outputs

| **Name** | **Key** | **Type** | **Description** |
| --- | --- | --- | --- |
| **encryptedData** | `encryptedData` | `String` |  |
<h4 id="decrypt">decrypt</h4>

Task key: `decrypt`



##### Inputs

| **Name** | **Key** | **Type** | **Description** |
| --- | --- | --- | --- |
| **privateKey** | `privateKey` | `String` |  |
| **passphrase** | `passphrase` | `String` |  |
| **encryptedData** | `encryptedData` | `String` |  |
  
##### Outputs

| **Name** | **Key** | **Type** | **Description** |
| --- | --- | --- | --- |
| **data** | `data` | `String` |  |
<h4 id="generate">generate</h4>

Task key: `generate`



##### Inputs

| **Name** | **Key** | **Type** | **Description** |
| --- | --- | --- | --- |
| **passphrase** | `passphrase` | `String` |  |
  
##### Outputs

| **Name** | **Key** | **Type** | **Description** |
| --- | --- | --- | --- |
| **publicKey** | `publicKey` | `String` |  |
| **privateKey** | `privateKey` | `String` |  |
Associating your git commits with a different email
Tags: git, tutorial
Published: 2020-01-23 04:25:09

If you have multiple computers or multiple github accounts like I do sometimes you get the commits associated to the wrong account. 

I'm currently in the middle of my [31 days of commits](https://dev.to/jsegal205/31-days-of-commits-4kga) challenge and have done this a few times already. Each time I had to look up the set of commands for how to do this, so I figured I would just document it for the next time I need it.

## Here we go

Check the git information: 
```shell
  git log
```
![git log showing incorrect commit authors](https://thepracticaldev.s3.amazonaws.com/i/syjc3jupqzhtk7vmtmqw.png)

## Alter multiple commits

### Find that commit
Find the commits that you want update and then copy the next commit hash. 
![git log highlighting commit to rebase to](https://thepracticaldev.s3.amazonaws.com/i/qzsdlf5tf36gz6bixlwl.png)


### Start the rebase
```shell
  git rebase -i -p <commit_hash> 
```
If you haven't updated your default editor, you are in vi. 

![git rebase in vi](https://thepracticaldev.s3.amazonaws.com/i/yzt8a0lqfizs79ebzplv.png)

Don't be scared. I'll help you through this with the following commands: 
- `i` to get into insert mode
- use arrow keys to move around and change the words `pick` to `edit`
- `esc` to get out of insert mode
- `:wq` to save and quit

![git rebase final look before saving](https://thepracticaldev.s3.amazonaws.com/i/18bmdi81h3ku1pwfeljh.png)

### Update each individual commit
```shell
  git commit --amend --author="Your Name <email@email.com>" --no-edit

  <enter>

  git rebase --continue

  <enter>
```

## Verify things are changed

```shell
  git log
```
![git log showing changed commit authors](https://thepracticaldev.s3.amazonaws.com/i/bnyjh4ip5ccjvi1kj95n.png)

Celebrate!
Could PHP fade away near future?
Tags: php
Published: 2020-01-23 04:16:44

> I don't use php anymore!!

I usually hear those words from my friends who used to be PHP hardcore developers. I am still using PHP and feel confident using PHP. But why? Most of the developers gave up PHP and use other languages.

And I have read this article [PHP Could Fade Away in Next Decade](https://medium.com/swlh/php-could-fade-away-in-the-next-decade-584e46d760db)

Please let me know your opinions.
goormIDE is very simple to share code.
Tags: ide, share, collaboration, tool
Published: 2020-01-23 04:14:10

Share the Project
It is easy to share projects on goormIDE. Share projects with your team members and make them better together. 
If you are a student, study algorithms with other people. 
With your container share link, you can ask about the code at a community. 
Depending on the share link settings, people can access without goorm accounts, which means you can quickly share with anyone!

1. Share Project in IDE
Click the [SHARE THIS PROJECT] tab on the left layout or go to [Project] > [Share this Project] on the Top menu. This will switch you to the project sharing tab like below.

1-1. Share via an e-mail
If you want to share your project with team members and work with them, share it via emails.

Please note that team members also have to have goorm accounts when you share via email. Write down the email address of your teammate and if it exists, it will be auto completed.

You can select permission of the user after choosing a user.

Read only (ro perm): Read only permission without file modifications. 
Can't modify in terminal commands either.

Editable (rw perm): People can edit your file. 
They have Read and Write permission of the workspace in the terminal.

Edifiable (root perm): People get root permission in the terminal.

Edifiable & Shareable (root perm): The highest permission. 
People get root permission and also granted to share the project directly.

When you finish permission settings, click the OK button in the bottom right corner to finish. 

Team members can see the shared project in their dashboard.

1-2.Share by link
If you want to temporarily share with someone, you can share it with a link. 
Users who share the link will be disconnected as soon as they close their browser. 
Depending on the settings, they can access without goorm accounts. 

Link ON / OFF: The ON / OFF switch on the right allows you to set ON / OFF for the link use.

All users connected via the link can be checked with the "Guest" mark.

If you want to export users who are sharing or accessing the project, 
you can export them by clicking the delete(bin) icon.

If you want to deactivate the share link, change it by clicking the Change link icon.

Link condition: The link can be set to operate only when the project owner is online.

Access option: 
(1) Anyone - Anyone can access to the container without goorm accounts. 
(2) Only with goorm users - goorm account is needed to access to the container. 
If they are not logged in, login page will automatically come up

Permission when invited: Granted permissions when people accessed through a link.

2. Share with a Dashboard
You can see the share link on dashboards also. 

If you want to set to share options, click the Configuration button at the top right corner of the project.

You can also see 'share via email' by clicking the Invite icon.
or 'share with a link' options here.
Debugging Product Hunt on Firefox with Proxyman
Tags: firefox, debugging, ios, tutorial
Published: 2020-01-23 04:01:24

---
title: Debugging Product Hunt on Firefox with Proxyman
published: true
description: A comprehensive tutorial on how to debug Firefox with Proxyman app
tags: firefox, debugging, iOS, tutorial
cover_image: https://thepracticaldev.s3.amazonaws.com/i/w1m7jupgxwneawj6grnb.png
---

In this tutorial, we would share how we quickly capture and debug HTTPS requests from [Product Hunt](https://www.producthunt.com) page via Firefox Browser.

From there, we can achieve several following tasks:
- Quickly filter the request
- See the HTTP/HTTPS request and message in a prettier format 
- Quickly change the param and test the production.

### 1. Proxyman
Proxyman is a Web Debugging Proxy and exclusively built for macOS. Basically, it can help you (developers) to debug out-going HTTP/HTTPS requests easily than looking via Console Inspector.

You can quickly download Proxyman from [homepage](https://proxyman.io) or execute ```brew cask install proxyman```

Then, we have to install the Proxyman Certificate via **Certificate Menu** -> **Install Certificate on this mac...**

and following the automation steps to install the certificate in a second.

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/w0y41uiazc2829uko0ie.png)

### 2. Install Proxyman Certificate on Firefox

It's crucial since Firefox has its Keychain instead of using the System Keychain. 

- Open proxy.man/ssl (It's a local server) in Firefox, trust and install the certificate properly

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/fjvppfi13ly2o4bmmpsv.png)

- If you don't see any Firefox request on Proxyman or couldn't access to proxy.man/ssl, please double-check the Firefox Proxy Setting in Preference.

The simple solution is that we select System Proxy Setting

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/r5wwdiwk0o79unsn3kbz.png)


### 3. Open https://www.producthunt.com in Firefox
As soon as you open the website in Firefox, it will list out in the Proxyman app like the following image.

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/ffq1biubpae9a5temzre.png)

Additionally, Proxyman comes with plenty of handy tools. Let start filtering and enable **HTTPS Response** on the **producthunt** domain.

After enabling, please make sure we reload the page again to get the updated content 👏

### 4. Start debugging
In these steps, we can see the HTTPS Content.

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/jk7k7fk9d3f84jyfsyc1.png)

Let try a few handy tools by right-clicking on the request.

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/fymq2hypyp7bw2fs7b6j.png)

Here is the tool list:
- Repeat: Repeat it to get new content
- Repeat & Edit: Able to change the query, header and test it out
- Local Map: Able to map the given local file as the response
- Breakpoint: Set a breakpoint on the request or response and change the data on-the-fly.
- and too many tools, which are waiting for you to discover 💪
Learning CSS by building a new CSS framework that fits few.
Tags: css, frameworks, beginners, bootstrap
Published: 2020-01-23 03:41:24

---
title: Learning CSS by building a new CSS framework that fits few.
published: true
description: Building a CSS framework that suits you.
tags: CSS, frameworks, beginners, bootstrap
cover_image: https://thepracticaldev.s3.amazonaws.com/i/xgpvs5ybamamoityydyp.png
---

There are a lot of CSS frameworks out there, I've easily [starred dozens]("https://github.com/atav1k?language=css&tab=stars") on Github. They come in all sorts of scopes and types from just grids to utility classes to massive enterprise ready projects. Given all that choice, you might wonder if we really need another framework.

**Absolutely yes. You should explore what fits your stack and mental model of HTML/CSS.**

The web standard isn't static, our frontend expressions shouldn't be either. We have BEM, SMACSS and OOCSS. Not to mention various pre-processors, LESS, SASS and PostCSS.

Developers find what suits them but one thing among these choices is that the complexity of HTML/CSS has to live somewhere. With CSS-in-JS it's in .js, with OOCSS it's right up front in the HTML classes. Which is to say there is no simple solution or silver bullet.

Define the constraints of your framework and go forth. With trim-css I wanted a framework that:
- Was free of preprocessors.
- Used CSS variables for theming.
- Had the simple syntax of React props.
- Was under <10kb gzipped.

## Syntax

``` html
<grid columns="8" gap="2" />
  <cell bg="black" color="white span="8">
    <h1 mx="4 sm2" my="sm2" p="2" />
  </cell>
</grid>
```

Here's a sample of how the framework is coming. Mind you it's experimental since it uses HTML custom elements. But more importantly it offers a sense of how we could speak frontend.

## Process

I've been keeping notes as I think about this project. Like core architectural choices I keep track of.

```
columns = columns
gap = gap
p = padding
m = margin
span = span
border = border
bg = background
color = color
```

Given that it's an experimental framework, I've been bookmarking all the resources I use as I explore what works and doesn't. That aside the thing I did differently this time was starting with a tester page. It's a really efficient way to build documentation and debug at the same time. 

![Screenshot](https://thepracticaldev.s3.amazonaws.com/i/xgpvs5ybamamoityydyp.png)

## Progress

I started with just the core. If I needed to spin up a microsite in 24 hours, what would I need? That forces you to prioritize. As of now there's really just grid, colors, text, and positioning. I'll keep you posted as I add components but in the meanwhile you can see the progress as I go on https://trim-css.netlify.com or just follow me here.
All About that Rebase
Tags: git, tools, rebase, merge
Published: 2020-01-23 03:39:05

---
title: "All About that Rebase"
published: true
description: Squashing some common Git merge patterns
tags: git,tools,rebase,merge
canonical_url: https://breen.tech/post/git-merge-patterns/
---

> I originally posted this on [My Blog](https://breen.tech/post/git-merge-patterns/).

## Background

Take 3 commits: **abc**, **def**, **ghi**
And let's suppose you have two git branches: **master** and **production**.

Production's history currently looks like this:

`abc`

Master is two commits ahead:

```abc -> def -> ghi```

You open a Pull Request to get **def** and **ghi** into **production**.

## Merge types

You have a few options for how to merge the Pull Request. All of these methods serve the purpose of getting the code from **def** and **ghi** into the **production** branch - the main differences center around the commit histories of the two branches afterwards.

### Merge Commit

I very rarely use this option in my work. As I understand it, it creates a sepearate commit, let's call it **jkl**, that describes the merging of **ghi** into **production**.

### Squash Merge
Squash merge combines **def** and **ghi** into a new commit, let's call it **mno**, and then merges that.

If you squash merge your PR, you'd end up with:

master:

```abc -> def -> ghi```

production: 

```abc -> mno```

The commit histories for **master** and **production**, even though they have the same code, no longer have the same commits in them.

### Rebase Merge

Rebase merge replays all of the new commits (**def** and **ghi**) onto production: 

```
abc
abc -> def
abc -> def -> ghi
```

At the end, **master** and **production** would look exactly the same.

## Conclusion

If I can help it, I prefer **Rebase merge**. It avoids creating new commits, so it often results in a cleaner commit history between branches. Sometimes I use squash merge if my branch has a bunch of commits like:

```
ahioh: feat: do something
inkcl: lint error
apsdq: fix test
apsap: please work
pwowq: Finally working
```

That way, the commit history doesn't show my stream of consciousness as I fight with linters, continuous integration, and test suites.

As I mentioned, I don't often use merge commits - I'm sure they have a use case, but I don't find them helpful to me a majority of the time.
Jawaban Tantangan 1 Kelas Coding Newbie 2020
Published: 2020-01-23 02:58:20

*Artikel ini merupakan bagian dari modul Pengenalan Coding di Kelas Newbie Komunitas Coding Mum Indonesia 2020*

Tantangan 1: https://dev.to/momnanaid/1-bagaimana-komputer-bekerja-5a4m

1.Terdapat 8 benda yang memiliki komputer/microcontroller di dalamnya

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/kyh4ft4scmi09f3q7plz.png)

####Mesin cuci

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/k0mfbunbpiytbo1jodpy.png)

Contoh gambar "komputer" di mesin cuci:

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/1ma9mw0l6edj0itkfr69.png)

####Lampu Lalu Lintas

Input: tombol pejalan kaki, stopwatch

Program komputer memberi tahu lampu lalu lintas kapan harus berubah dari merah ke hijau.

Ketika pejalan kaki menekan tombol menyebrang jalan, ia memberi tahu komputer bahwa ada yang ingin menyeberang. Lampu merah untuk kendaraan dan lampu hijau penyeberangan pejalan kaki akan menyala.

Output: warna lampu

####Pintu Otomatis

Input: kamera, sensor

Pintu otomatis menggunakan program.
Ketika mereka merasakan seseorang dekat, mereka terbuka. Mereka hanya menutup jika jalannya jelas.
Mesin Uang

Output: buka/tutup pintu

####Mesin ATM

Input: tombol / layar

Mesin ATM menjalankan program komputer yang memungkinkan orang membuat pilihan tentang uang mereka.

Ketika mereka meminta sejumlah uang program komputer memeriksa apakah ada cukup uang di dalam akun dan mesin.

Output: layar, uang tunai, tanda terima


####Pemutar MP3
Input: tombol
Memproses: Program memungkinkan Anda memilih di antara lagu dan memutarnya.
Output: earphone


####Kamera
Input: lensa, cahaya dari benda
Processing: refleksi cahaya dari benda menjadi gambar
Output: gambar/foto

####PC
Input: keyboard, mouse
Processing: CPU, proses input menjadi biner kemudian komputer memproses instruksi sesuai rancangan program
Output: layar, speaker, printer (jika ada)

####Konsol permainan
Input: tombol
Processing: proses perintah dari tombol. Misal jika tombol kiri ditekan, layar menampilkan object di program permainan bergerak ke arah kiri.
Output: layar, speaker 

------------------------

2.Catatan: huruf besar dan kecil dari huruf yang sama memiliki kode biner yang berbeda. Contoh: RATNA berbeda dengan Ratna

------------------------

3.Catatan: beberapa mikrokontroler memiliki sensor yang memantau perubahan di lingkungan. Contoh:

Suhu: Ketika suhu menjadi panas, lakukan ini:
Orientasi: Ketika pintu dibiarkan terbuka, lakukan ini:
Getaran: Ketika seseorang mengetuk pintu, lakukan ini:
Kelembaban: Saat hujan, lakukan ini:
Internet: Ketika ada mainan baru yang dijual, lakukan ini:

Kita bisa merancang berdasarkan sensor di atas.

Contoh: smart home. 
Lampu yang bisa nyala dan mati sendiri
Input diperoleh melalui sensor cahaya. Jika cahaya redup, lampu menyala. Jika cahaya terang, lampu mati. Lampu juga bisa dikontrol melalui aplikasi di handphone.

{% youtube hpb-ZiQvuZ8 %}
webMethods.io Embed
Tags: webmethods, integration, ipaas
Published: 2020-02-07 09:01:24

---
title: webMethods.io Embed
published: true
date: 2020-01-22 14:26:00 UTC
tags: #webmethods, #integration, #ipaas
canonical_url: http://techcommunity.softwareag.com/techniques-blog/-/blogs/webmethods-io-embed
---

# Powering embedded integrations

**Recently Software AG has released webMethods.io Embed, an embeddable iPaaS - empowering development teams to efficiently embed in-app integrations into their products to enhance their offering with connectivity to a variety of cloud apps and services.**

## Why in-app integrations?

Cloud applications require integration with other apps and services to survive and thrive. This is why more and more SaaS vendors are enhancing their solutions with connectivity to third-party apps. In-app integrations to other cloud applications and services unlock additional capabilities for your end-users, empowering them to do more with your own offering without the need to switch between different applications and UIs. The goal is to increase customer adoption and retention.

## Embedded integration

But building integrations without the right tools and specialized integration know-how requires a lot of work. You need to explore the API of the app that you want to integrate. You need to build and test the integration. You need to monitor the API to make sure that if the API changes your integrations won’t break - over and over again for every new integration. All this effort requires developer time, taking it away from building the differentiating capabilities of your own app, and it slows down your time to market.

Embedded integration solves this problem, providing intuitive tools to create and publish the integrations you need in a more efficient and standardized way. As the name says - it allows you to “embed” integrations with third-party apps into your application so users can interact with other apps and services right within your own app experience. Pre-built app connectors ease the pain of dealing with API documentation and changes, so you can avoid maintenance chaos. Once it is set up, you can add new integrations with a click of the button and easily manage them across their lifecycle.

## Learn how webMethods.io Embed enables you to:

- Easily plug integration capabilities into your application
- Accelerate your time-to-market, reduce development and maintenance costs
- Provide more value for your users

{% youtube t-LKZU2Cen0 %}

[Visit our website](http://softwareag.com/embed) to learn more about webMethods.io Embed and request a custom demo.
Oops, I just pushed a git commit to the wrong branch. What now?
Tags: git
Published: 2020-01-23 01:41:02

  We are currently running off two active branches in our git repository.  And by accident I just committed an update on the wrong branch and pushed it.  Luckily, getting out of this mess isn't hard.

The erroneous commit is 65c356c8c

First, lets pull the commit from Branch1 into Branch2 where it should be...

```javascript
   git checkout Branch2 
   git cherry-pick 65c356c8c
```

This pulls the commit across into the correct branch.  Great.  We can now push the commit is normal.  But what about the commit still sitting on Branch1 in my local index?  Lets fix that now.

```javascript
   git checkout Branch1
   git reset --hard HEAD~1
```

This will reverse the last commit.  

As with all git issues, the secret is to not panic.  Jump on the net and find a simple solution.
Identify if ColdFusion Query Row is "empty"
Tags: coldfusion, sql, cfml
Published: 2020-01-23 01:35:22

I'm using the [Handsontable](https://handsontable.com/) javascript gid component. It provides my web applications the ability to copy/paste columnar data, review and edit before importing.  During the online "save" process, the SheetClip plugin stringifies the data and it's posted it to the ColdFusion application server where it's converted it into a query-of-queries (using a CSV-to-Query UDF that I have) and then the individual rows are inserted into the database.

I've also encountered strange issues where multiple empty rows are retained after reading an Excel file via cfspreadsheet.

I was trying to determine the easiest way to identify whether the query row was empty so I wouldn't have to perform any inline `if/then/else` logic on all of the columns. I didn't find any pre-existing UDF at [CFLib.org](https://cflib.org/), so I sat down and wrote this.

## Live Demo via TryCF.com

[https://www.trycf.com/gist/796c63867cb426b5f5fad791cdcfa4b2](https://www.trycf.com/gist/796c63867cb426b5f5fad791cdcfa4b2)

## Source Code

{% gist https://gist.github.com/JamoCA/796c63867cb426b5f5fad791cdcfa4b2 %}