teleren/devto huggingface dataset:
Frontend and API
Published: 2022-11-18 19:09:37

Frontend & Backend Programming
 
Web development is the process of building websites and applications. The important thing about web development is its coding and programming powers its functionality. This functionality relies on the frontend (client side) and the backend (server side).

The frontend of a website refers to everything that the user experiences directly. Things like the layout, font, and colour are all driven by the front end. A static website is a website that the content stays pretty much the same and the necessary information that determines what is on the page is contained within the frontend code. HTML CSS & JavaScript create everything that is visually presented to you on a website.
 
The backend is the part of the website the user doesn’t see. It usually stores & organises data and ensures that everything on the frontend runs smoothly. A dynamic website is a website that the content can change based on the user’s input and what is stored in the database. Some common backend coding languages include Ruby, Python, PHP, and Java.
 
API (Application programming Interphase) makes it possible for different systems to interact with each other. It helps these systems in exposing some of their data. API is an interphase that is a way that you cab talk to the actual system.
Cracking Amazon-style coding interview
Tags: beginners, tutorial, programming, python
Published: 2022-11-18 18:46:31

Would you like to know how coding interview in companies such as Amazon or Microsoft looks like?

In this video I will:
- recap the structure of Amazon-style interview
- explain the strategy that I think should help to pass an interview
- make a simplified demonstration of how the interview may look like and how I would approach it

{% embed https://www.youtube.com/watch?v=825e3BS421g %}
Environment setup stuff
Published: 2022-11-18 18:37:52

## Intro
A whole bunch of commands for setting up an environment to use Ruby, Node.js, and git on WSL.

### node
```sh
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh | bash
```
restart
```
nvm install --lts
```

### ruby/rvm
```
sudo apt-get install software-properties-common
sudo apt-add-repository -y ppa:rael-gc/rvm
sudo apt-get update
sudo apt-get install rvm
sudo usermod -a -G rvm $USER
```
restart
```
rvm install 3.2.2 --default
gem update --system
```

### git
```
sudo add-apt-repository ppa:git-core/ppa
sudo apt update
sudo apt install git
```

Good config defaults
```
git config --global color.ui true
git config --global init.defaultBranch main
git config --global core. editor "code"
```

Create an ssh key for github. Don't enter passwords, otherwise you will have to type them every time you try to push code.
```
ssh-keygen
```

Copy your SSH key to the clipboard
```
cat ~/.ssh/id_rsa.pub | clip.exe
```
Paste into [https://github.com/settings/ssh/new](Github ssh key form)
Java 101 - How Java Works!
Tags: webdev, java, codenewbie
Published: 2022-11-18 18:24:30

Instruction

Programs written in Java are executed utilizing the Java Virtual Machine (JVM). The JVM is a unique program that knows how to execute the programs that you write in Java.

The Java Virtual Machine can run our code because it runs our compiled bytecode. This is unique as it does this in a virtual environment that is the same across every platform. However, the JVM that you use is specific to your operating system.

 

To run our code, it has something called the Just-In-Time Compiler (JIT). The JIT turns your bytecode into machine code pretty much line by line.

 

So programs in Java are technically compiled twice.

 

To run Java code, you also need a JRE - Java Runtime Environment, which contains all the runtime libraries that your code will be calling and using. The JRE has the JVM, so if you want to run a Java program, all you need to install is the JRE.

 

But how do we compile the Java code that we write down to bytecode that the JVM will understand? For that, you need a JDK - Java Development Kit, which provides developer tools like a compiler, debugger, documentation tools (JavaDoc), and other command-line utilities. The JDK also has a JRE inside of it, so if you install a JDK, you can compile your Java code and execute it.

 

So let's do an overview of how everything works!

 


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bzfsr96mv087f7r15zcs.png) 
 

Step 1: The developer would write the source code in which the JDK would compile and turn the source code into bytecode.

Step 2: The JRE processes the bytecode line by line using the JIT.

Step 3: Finally, the JIT compiler turns the bytecode into machine code, basically line by line.

 

With that being said, this can name each process as it goes through.

 

For instance:

Compile Time- this is when source code is converted at one time to bytecode. So as I type the source code it is being compiled.

Runtime - this is when Java uses the JIT, the bytecode that the developer wrote is then turned into instructions for the machine to execute.

 

So, to recap - the JDK contains tools for Java development as well as a JRE, which contains the built-in Java libraries as well as a JVM, which actually executes your Java bytecode and runs it on the specific operating system it is installed upon.
Weather Forecast from sensor data , Azure IOT Hub, Stream analytics and Machine Learning Studio
Tags: azure, machinelearning, iot, steamanalytics
Published: 2022-11-18 18:14:41

Weather Forecast from sensor data , Azure IOT Hub, Stream analytics and ML Studio
Machine learning is a technique of data science that helps computers learn from existing data to forecast future behaviors, outcomes, and trends. ML Studio (classic) is a cloud predictive analytics service that makes it possible to quickly create and deploy predictive models as analytics solutions. In this article, you learn how to use ML Studio (classic) to do weather forecasting (chance of rain) using the temperature and humidity data from your Azure IoT hub. The chance of rain is the output of a prepared weather prediction model. The model is built upon historic data to forecast chance of rain based on temperature and humidity.

Complete the Raspberry Pi online simulator tutorial or one of the device tutorials. For example, you can go to Raspberry Pi with Node.js or to one of the Send telemetry quickstarts. These articles cover the following requirements:
An active Azure subscription.
An Azure IoT hub under your subscription.
A client application that sends messages to your Azure IoT hub.
An ML Studio (classic) account.
An Azure Storage account, A General-purpose v2 account is preferred, but any Azure Storage account that supports Azure Blob storage will also work.

- Introduction to Weather Forecasting using azure services 
- Use case of Weather Forecasting using azure services 
- Create IOT Hub In Azure Portal
- Create Devices in Azure Iot Hub
- Azure Iot Hub Explorer
- Raspberry Pi Simulator
- Connect Device to Azure Iot Hub
- Create Azure Stream Analytics Job 
- Connect IOT to Azure Stream Analytics
- Create Predictive Experiment in Azure Machine Learning Studio
- Add Machine Learning web service as function in Azure Stream Analytics
- Run Azure Stream Analytics Job
{% embed https://youtu.be/7cfe1vdnDLE %}
InnerText vs. InnerHTML vs. TextContent
Tags: javascript, webdev, beginners, html
Published: 2022-11-18 18:12:54

# Which do I use? When? Why? 

You aren't alone if you find it daunting on which of these to choose and the nuances between them. This post will help break down, and give you a better understanding of them and when it's appropriate for each to use.

## The Breakdown 

These all share basically the same core function - which is to pull the contents inside elements. It begins to vary when it comes to what content is grabbed, and how it is also rendered on the page. 

We will start with a few comparisons between InnerText and TextContent:

- Mainly, TextContent allows you to grab **ALL** elements, where as InnerText is only going to use what's considered human readable elements. 

- InnerText can read CSS styles and will display them, TextContent will only display the content without any styling.

Here's a photo example from [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/innerText) showing how innertext and textcontent display differently 
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rm6takmzb6nqdlrm8odt.png)



[MDN](https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent#differences_from_innertext) has great references for getting a deeper understanding of how these all relate to each other and how they differ as well. I highly recommend using that site as much as you can in general, although there is a lot of information to sift through - it is very reliable and thoroughly explained.

## InnerHTML
This one gets a little more confusing, and I feel like depending on the person you ask, you will get different opinions as to how they feel about using it. InnerHTML will actually take the text and whatever html tags are attached with it and either replace them with your assigned content, or you can grab existing content and append new contents to the existing one of an element. Take a look at [MDN's](https://developer.mozilla.org/en-US/docs/Web/API/Element/innerHTML) documentation explaining the usage and **DANGER'S** of using InnerHTML over the other methods.
Understanding Emacs
Published: 2022-11-18 18:11:54

## What is Emacs? 

Emacs is an acronym meaning Editor Macros(EMACS).

> Emacs is an extensible, customizable, self-documenting, real-time display editor.

`The original EMACS was written in 1976 by David A. Moon and Guy L. Steele Jr. as a set of Editor MACroS for the TECO editor.`

## Who is Richard Stallman?


> Richard Stallman created the most popular, and most ported, version of Emacs called GNU Emacs, which was created for the GNU Project.


## How to open and save files

To Open a file within emacs type. 

```
Ctrl-x Ctrl-f [file]
```
To Save a file within emacs type.
```
Ctrl-x Ctrl-s
```

## What is a Buffer and how to switch from one to the other?

> Buffers in Emacs editing are objects that have distinct names and hold text that can be edited.

` Buffers are used to hold the contents of files that are being visited; there may also be buffers that are not visiting files. Although several buffers normally exist, only one buffer is designated the current buffer at any time. Most editing commands act on the contents of the current buffer. Each buffer, including the current buffer, may or may not be displayed in any windows.`

How to switch to between Buffers
`- when the buffers names are not known`
```
Ctrl-x b
```
`- to list all the buffers`

```
ctrl-x B
```

## How to use the mark and the point to set the region?
`You set the mark at one end of a text, and move point to the other end. The text between point and the mark is called the region.  `

To set mark on a text type 

```
Ctrl-SPC(Set-mark-command)
```

## How to cut and paste lines and regions.

- To cut the text, type

```
Ctrl-w
```

- To copy the text, type

```
Alt-w
```

- To paste the text, type

```
Ctrl-y
```

## How to search forward and backward.

Search Forward

```
Ctrl-s
```
Search Backward

```
Ctrl-r
```

## How to invoke commands by name.
To invoke a command by its full name, type 

```
M-x(Alt-x)
```
, then the name of the command, and finally hit RETURN.

## How to undo.

 To undo type any of the three below

```
Ctrl-x u
# OR
Ctrl-/
# OR
Ctrl-_
```

## How to cancel half-entered commands

To get rid of a partially typed command

```
Ctrl-g
```

## How to quit Emacs

When you want to leave Emacs for a short time, type 

```
 Ctrl-z 
```
and Emacs will be suspended. 

To get back into Emacs, type 

```
%emacs
```
 at the shell prompt. 

To quit Emacs permanently, type 

```
Ctrl-x Ctrl-c.
```
DPS909 Blog :LAB 9 Add Continuous Integration
Tags: opensource, beginners
Published: 2022-11-18 17:56:15

## Overview

To use the CI/CD and automation on GitHub

### So, what exactly is GitHub Actions?

GitHub Actions is a native CI/CD tool that runs alongside your code in GitHub. In fact, you may have noticed a tab that says “Actions” in a GitHub repository at some point.
GitHub Actions gives developers the ability to
automate their workflows across issues, pull
requests, and more—plus native CI/CD
functionality. 

All GitHub Actions automations are handled via workflows, which are
YAML files placed under the .github/workflows directory in a repository
that define automated processes.

## Most common use cases for GitHub Actions

- Build, test, and deploy within the GitHub flow
- Automate repetitive tasks
- Manage users easily at scale
- Easily add preferred tools and services to your project
- Quickly review & test code on GitHub


### Link to my repo
  [ag-ssg](https://github.com/anshul137/ag-ssg)

## How to setup github action

  [Github Actions](https://docs.github.com/en/actions)

 After setting up the github Action into my account my YMl file look like this 


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/63jwxyqjkfr9ptsx58xt.png)

I have also create the Prettier action in my Repo YML file look like this.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4xj0w3mfwwjw4iiw5rrf.png)


Thanks
Top 10+ most dead-easy ways to make a web app
Tags: webdev, javascript, react, lowcode
Published: 2022-11-18 17:53:57

The diversity of web applications includes more complex ones, such as project management, video editing, computer-aided design, etc., as well as simpler ones, including discussion boards, visitor sign-in books, and email programs.

And here we return to the burning question, which is the most dead-easy way to make a web app? The answer is the surface use of codebase generation tools or generators. In this article, we will show you the most popular [web application generators](https://flatlogic.com/blog/top-10-most-dead-easy-ways-to-make-a-web-app/). We also welcome any feedback from you on this article, as well as on improving [our product](https://www.youtube.com/watch?v=DqFRBThafJs).
edrra.com multi-service API
Tags: api, search, sms, database
Published: 2022-11-18 17:40:44

**[edrra.com](edrra.com) API is too easy and powerful for multi-service APIs like:**
1. Database API
2. Google search API
3. Translator API
4. Crypto payment API
5. Send SMS API
6. Weather API
7. Temporary phone number API
8. Temporary email API
_and much more._
Dealing with Imposter Syndrome
Tags: career, advice, beginners
Published: 2022-11-18 17:36:21

If you're a new developer, getting ready for your first interview, you might start feeling something known as _imposter syndrome_. 

You spent countless hours learning how to build applications. But the hours with your head in books, and your eyes on the screen don't seem good enough. _Maybe you don't know this stuff as good as you should_. 

Welcome to imposter syndrome, something [58% of tech employees report experiencing](https://www.teamblind.com/blog/index.php/2022/02/14/impostor-syndrome-work/).

It is a horrible feeling. Let's explore some ways to get over this dreaded feeling. 

## Your interview process is a learning process.

Technical interviews can be extremely difficult. You never know how they're going to be. Maybe a phone screen, and a take home project (we wish!). Or maybe it's going to be 4 phone calls with a recruiter, a technical interview, and then a meet with the team (the most dreaded).

Whichever interview you find yourself in, you must try to use it to your advantage. Take notes of everything you've been doing. Whether you succeed or not isn't the end of the world, and you're not going to be at a complete loss - you're going to learn how to interview. The more you do it, the better you will be at it, as with everything in life. 

## Stop worrying about what others think of you.

This is why we experience imposter syndrome. We're afraid that we're going to be exposed as fake developers. That the interviewer is going to tell the rest of the team how _stupid_ we were. 

Enough of this. We have no control over other people perceptions of us. What we do have control over, however, is our ability to present ourselves in a way that _we can accept_. To perform our best is what's important. 

## Hope for the best, prepare for the worst.

Most of us visualize our success. We never imagine our failures beforehand. The end result is us being devastated after we do horrible during an interview. _It should have went smoothly!_ 

Take time to visualize the negative events that may happen during your interview. You might forget a simple array method. You might start stuttering. There's an endless possibility of things that _could go wrong_. 

Why do this? So that, if things do go wrong, you were prepared for them to go wrong. The effects on your mind will be less. If you never imagine things going wrong, you will be devastated when they do. 

## Conclusion 

We hope these tips help prepare you for your next interview. If you have other tips, please add them to the comments. 

**Note**: This is a shorter version of an article published, here: https://blog.javascripttoday.com/blog/overcoming-imposter-syndrome/
SQL Server Loop Example
Tags: sql, sqlserver, data, database
Published: 2022-11-18 17:33:35

![SQL Loop Code](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jf9ajckx7bgcn3o7dy96.png)

I needed to run a LOOP statement in SQL. Normally I would do this with website server-side code (ex. PHP or Node.js), however this was needed for data analysis that I otherwise didn’t have a need for writing web-based code.

I needed a solution compatible with MS SQL Server Management Studio ("SSMS").

## Why even do this?
I had a database table with millions of rows and I needed to create a table with a subset of this data.

To create the table, I needed to run several INSERT queries; each having only slightly different WHERE criteria.

By using a LOOP, I could dynamically create the table- and have a repeatable process as it would have to be done often.

## How to write a loop using SQL
Here’s the code, explanation is below.
{% embed https://gist.github.com/stevesohcot/53511164ad7f7703d0e52860a1baaa33 %}


Let’s start with some fake data.

- Rows 1–5 create a temporary table
- Rows 7–13 populate this table with data
- The value passed into my WHERE criteria (in my eventual INSERT statement) would be dynamically changing as it loops. The value will be stored in a variable called theOrg, declared on line 17.
- I’ll need to loop through a finite number of rows: starting at “1” (Row 18), and up through the number of rows in my temporary table (Row 19)
- Rows 21–29 is the actual loop:
- Row 24 gets the specific value that I’ll ultimately be querying on, based on a SELECT query using the variable cursorId
- Row 25 is where I could run an INSERT statement to generate the table, although here I’m using a SELECT statement for demonstration purposes
- Row 27 increments the variable cursorId so that the loop will continue
- Running it in SSMS, you’ll see this:

![SSMS Output of SQL Loop](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/303nwnfit0ia2pmml7vn.png)


Of course, now I can swap out the SELECT statement (Row 25) and use my real query (with an INSERT statement) to generate my dataset.
OSD600 Lab 9
Tags: beginners, opensource, cpp, python
Published: 2022-11-18 17:23:10

## Setting up CI using GitHub Actions
This week, I set up CI for [my SSG project](https://github.com/rudychung/SauSaGe). This involves creating a GitHub workflow for GitHub Actions to use. I started with one of the [starter workflows](https://github.com/actions/starter-workflows/tree/main/ci). Specifically I used the [msbuild](https://github.com/actions/starter-workflows/blob/main/ci/msbuild.yml) one. To give a brief explanation of what adding this file will do, upon pushing changes or, a pull request it will create an environment that can be used to run my program. This is helpful if any tests, or other checks need to be made to verify that everything is in working order after changes to the project have been made. 
## My YAML file
[My YAML file](https://github.com/rudychung/SauSaGe/blob/main/.github/workflows/ci.yml) built the project on Windows and used my `.sln` file to build the project. Then, it ran the tests for my project using the built executable file. Other tasks such as using a linter to check the source code could also be performed at this point in order to validate it further. 
## Testing another project
How did your partner's repo and testing setup differ from yours? 
I worked with [sfrunza13](https://github.com/sfrunza13) once again on [his SSG](https://github.com/sfrunza13/SiteGenerationTool). Even though he used Python and I used C++ for our projects, the tests were similar since they both accomplish the same task. With the understanding of the task being performed, the difference between languages did not matter significantly. Both the projects and tests were very similar. Although one significant difference was that my repo outsourced the Markdown parsing to a external module. 

It was very simple to create new tests when using the existing tests as an example. Since I am still not 100% familiar with Python, it took me a little getting used to before writing my tests. However, I had worked with a previous iteration of the project before, so I did have prior understanding of how it functioned. But, there were some changes made to it in the time between the last time I worked on it and now that I had to re-read and understand the changes made to the project. 

## My opinion on CI
It's a very convenient way of handling contributions to my project. I can see it being very helpful in larger projects, which may get hundreds of pull requests. They would help greatly in ensuring that changes being merged do not break the project. The powerful thing about CI is that all these checks are done automatically, which greatly eases the burden of the authors and contributors of the project in terms of checking incoming changes.
Being a Developer Advocate: Week 11
Tags: devrel, learninpublic
Published: 2022-11-18 17:13:13

We are getting serious with our community efforts. But first things first.

## Meetup - Live Sketchnoting
I am a huge fan of sketchnoting. In 2019 I had the chance to attend a 6-hour sketchnoting workshop and got hooked on it. it is amazing what you can do with nice pens and a little bit of imagination. Although I lack the skill to draw they usually turn out good enough 😍

With macOS Ventura you can use your iPhone as a webcam and with an old tripod and a smartphone holder I managed to live sketchnote our meetup this week. This is something I will do regularly now as it adds another layer to the talk experience. And you have a gift for your speakers!

![Sketchnote of Meetup](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/htus8q7ywk73p4g75mn6.jpeg)

## Community Reboot
We noticed that we actually have two communities in one Discord space. The one from our meetup and one for our product. In our team, we agreed upon narrowing our Discord down to just our product. That should give us more focus!

## Content Syndication
We also started to explore content syndication opportunities to reach more developers.

I am hopeful this will lead to better awareness.

If you want to read up on why and how you should content syndication, there are two nice blog posts from the folks from [draft.dev](https://draft.dev/)

* [Content syndication](https://draft.dev/learn/syndicating-developer-content)
* [Content marketing](https://draft.dev/learn/promotion)