teleren/devto huggingface dataset:
How to start learning Augmented Reality from scratch?
Tags: android, ios, technology, augmentedrealiy
Published: 2021-02-01 09:25:20

`This will guide you to available resources to understand Augmented Reality concepts from scratch.`

>“What makes innovative thinking happen?… I think it’s really a mindset. You have to decide.”- Elon Musk

![AR](https://dev-to-uploads.s3.amazonaws.com/i/v3m3hj6mow238637tjia.jpeg)
**Augmented reality (AR)** is an experience where designers enhance parts of users’ physical world with computer-generated input. AR part of the surrounding environment is actually ‘real’ and just adding layers of virtual objects to the real environment.

A medium in which digital information is overlaid on the physical world that is in both spatial and temporal registration with the physical world and that is interactive in real-time

{% youtube 24SaS8SkVR4 %}

**Fundamentals Concepts**
* Tracking
* Environmental Understanding
* Light Estimation
* Occlusion

**Small Concepts you need to know**
* Placing
* Scaling
* Solid Augmented Reality assets

### Tracking
   AR relies on computer vision to see the real world and recognise the objects in it. The process of scanning, recognizing, segmentation and analyzing environmental information is called *tracking*.

* Inside out
* Outside In
* [Motion Tracking](https://developers.google.com/ar/discover/concepts#motion_tracking)

### [Environmental Understanding](https://developers.google.com/ar/discover/concepts#environmental_understanding)
   The ability to detect and generate a flat surface is known as Plane finding. Information about the physical world around AR devices. A major part in Environmental understanding, how it is detecting the planes or horizontal surfaces in an area.

##### Anchors
User-defined points in which AR objects are placed. A virtual object attached to a featured point, which is identified and tracked by Simultaneous localization and mapping (SLAM).

[**Types of Anchors**](https://learningsolutionsmag.com/articles/understanding-anchors-in-augmented-reality-experiences#:~:text=Anchors%20are%20objects%20that%20AR,real%20world%20detection%20and%20tracking.)
1. Plane Anchors
2. Image Anchors
3. Face Anchors
4. 3-D Anchors

### [Light Estimation](https://developers.google.com/ar/discover/concepts#light_estimation)
Detecting the lighting automatically of the place around, which forms a better appearance of virtual visuals for the users.
![Light Estimation ](https://dev-to-uploads.s3.amazonaws.com/i/qy8e551dp3a3htza4x82.png)

### [Occlusion](https://medium.com/selerio/occlusion-is-important-in-ar-9a672ff9ca2d)
When one 3D object blocks another 3D object from view is known as Occlusion.
![Occlusion](https://dev-to-uploads.s3.amazonaws.com/i/zs8ukju52p9j6897rn6z.png)

Click [here](https://www.youtube.com/watch?v=q9PFFqAABBM&ab_channel=6D_ai) to understand more.

##### Online Courses:
1. [Introduction to Augmented Reality and ARCore.](https://www.coursera.org/learn/ar/)
2. [Handheld AR App Development with Unity.](https://www.coursera.org/learn/handheld-ar)
Tuesday JS visual novel engine (open source)
Tags: javascript, gamedev, github, visualnovel
Published: 2021-02-01 09:16:39

Introducing Tuesday JS editor for Visual Novels and Interactive Stories for the Browser! It will allow you to create your project without any programming knowledge on any desktop PC with a modern browser.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/w2qwp2296awt8cfpsv7a.png)

The main difference from most similar editors is the graphical display of the script structure through blocks with all dialogs, choices and other plot elements. For best clarity, blocks can be assigned with colors in accordance with the mood of the plot or individual branches of characters in such an image, which is important for scriptwriters working in game development.

![Alt Text](https://kirilllive.github.io/tuesday-js/screenshots/scene_editor.png)

The scene editor can not only arrange all the elements in their places, it also shows how the scene will change on different screens. On it, you can change the screen size, aspect ratio and orientation in real time, without being distracted when you are editing the scene and to make changes quickly. In your scene layout, you can use standard HTML units in percentage pixels or centimeters to better adapt the scene to different screens.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/o69jcpumy2td0ek9ebnt.png)

The environment Tuesday JS provides an ample opportunity to localize your story to other languages, you can set translation for almost any element, either text or image, with that you can fully convey your idea in another language, not only in words, but also through place actions. For the convenience of translation, you can export all texts in the CSV spreadsheet format (in the future I also plan to import the translated texts back).

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/7l9b0bryw8z0u2a0zf2n.png)

The novels created do not use canvas technology to display graphics, they use standard HTML components, you can use css styles, svg vector graphics and gif animation just like when you create a regular website.

But if the capabilities of Tuesday JS are not enough for you, all your project data is stored in JSON format, it can be read by most programming languages or game engines. And if you're good at programming, Tuesday JS can offer a very flexible API to interact with history and extend its functionality.

The goal of Tuesday JS is to make project development no more difficult than working in an office program to make presentations, and does not require special skills from the user.

[Home Page](https://kirilllive.github.io/tuesday-js/)

[itch.io](https://kirill-live.itch.io/tuesday)

[GitHub](https://github.com/Kirilllive/tuesday-js)
Static Site Generators
Published: 2021-02-01 08:51:13

---
title: Static Site Generators
published: true
description: Static site generators - why you should consider using one
canonical_url: https://www.garybell.co.uk/static-site-generators/
cover_image: https://static.garybell.co.uk/images/32-static-site-generators/pankaj-patel-Ylk5n_nd9dA-unsplash.jpg
---
There is more and more focus on the performance of a website, and the effect performance has on search engine rankings.
Performance is the first metric loaded by Google's lighthouse audit.
The obvious reason why this is the case, is that Google wants to get the information to users as fast as possible.

The ultimate goal for any website is to get 4x100 ratings across the lighthouse audit, both on desktop and mobile.
Getting to that rating isn't always easy. Performance is the hardest to hit (in my opinion).

At the time of writing, the performance metric for my website homepage was sitting at 91/100.
![My desktop rating](https://static.garybell.co.uk/images/32-static-site-generators/website-desktop-performance.png)

On mobile, the story is different. It's a much lower at 75/100.
![Mobile lighthouse performance](https://static.garybell.co.uk/images/32-static-site-generators/mobile-performance.png)

## Where's the Bottleneck
The slow part of most sites is due to the CMS in the background.
A lot of the time taken for a page to load is the communication between the CMS code and the database.
In a lot of cases this requires requests across the network to communicate with the database.
The returned data then need to be processed to generate the page content, which can then be returned to the user.
Each of these steps takes time.

If you can remove some of those steps, then the speed of the site will naturally improve.
This is where a static site generator comes in.

These remove the requirement to perform some of the steps.
Specifically any of the database and processing work.
It does this by building the page once, and storing it as a html file on the webserver.
This means the visitor is served the information they requested directly, because the page which would be built from the CMS at each request is already generated in full.

There are a lot of options out there if you want to use a static site generator.
A list of 314 (probably not even comprehensive) is available on the [jamstack website](https://jamstack.org/generators/).
I'll be taking a look at a few of the PHP based ones in a future edition.
For now, I'll let you go and marvel in amazement at how many options there actually are for static site generation (and that doesn't count hand-crafting the HTML).
Different Ways to write css.
Tags: css, html
Published: 2021-02-01 08:43:39

If you know some about html and css you may be encountered one thing that is without css it seems like body without muscles.its too ugly that's why I especially love css.
I run <a href="https://www.howto2.in/"style="color:brown;text-decoration-line:none;">blog </a> website and use css.
There is three different ways to write or code css
1) Inline css
2) Internal css
3) external css
You can use these css different ways to style your html documents.
Understanding Docker: part 29 – Exec in a container
Tags: docker, devops, beginners, cloud
Published: 2021-02-01 07:59:16

---
title: Understanding Docker: part 29 – Exec in a container
published: true
description: Serie of sketchnotes about Docker. Explaining in a visual way Docker principles.
tags: Docker, DevOps, beginners, Cloud
series: Understanding Docker in sketchnotes
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/xlrmwdlfopubc5mwn4f4.jpeg
---

Understanding Docker can be difficult or time-consuming. In order to spread knowledge about Cloud technologies I started to create sketchnotes about Docker. I think it could be a good way, more visual, to explain Docker (and other technologies like Kubernetes and Istio).

We continue the series of Docker sketchnotes with an explanation about how to exec in a container.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/xlrmwdlfopubc5mwn4f4.jpeg)

As usual, if you like theses sketchnotes, you can follow me, and tell me what do you think. I will publish others sketchs shortly :-).

If you are interested, I published all the sketchnotes on Docker (and new ones!) to make a "book" of 93 pages: ["Understanding Docker in a visual way"](https://gumroad.com/aurelievache#YTLzM).
My Steps of Online Learning
Published: 2021-02-01 07:39:46

There are many ways to enhance or learn new skills that takes you to the next levels. But nowadays, most people are used to learn online (i.e. through web) because it's easy way to update yourself rather than any dependencies on anything. Web surfing is a great way to learning any specific skill to update yourself.

**Problem during web surfing** 

Many times people are distracted themselves while finding any particular about any specific topic as we all know that its a huge ocean of WWW (World Wide Web) and we can get these kind of difficulties very often.  

Let me tell you my experience about the same. Whenever I am trying to learn any new thing through online, I often distracted when many options or solutions are available, I got difficulties what to choose OR what will be my best answers. So, I defined some steps according to my roadmap. 

**Step-1 : Dedication towards your goal** 

First-most thing is to decide what you needs to learn from upcoming days, months or years and stick into it. Because if you are creating the roadmap of your upcoming skills than its most important part to search about only specific what you intend to achieve. Goal should not be changed once you defined it.

**Step-2 : Define the path and platform**

Once you decide your goal then many solutions are available to serve you the best. Suppose I am trying to learn my IT related skills let's say JavaScript. So there are many web sites or courses that teach me JS but I need to think whether I will go for websites or to join any specific course according to my feasibility. May be I can go for intro by some of the websites then jump to the course or will find such course which provides me the intro as well as full brief about the JS. This can be vary person to person. But once I defined my way then again its a question about which course should I joined or which website should I prefer ?
To answer this question, I will check some official websites and courses and choose one of them and defined my learning path.

**Step-3 : Prove your skills**

Now, best thing is to apply your learnings practically. Keep in mind that `"Theories will remain theories unless you prove it practically"`. Each and every learning, you need to prove your knowledge by apply it into some practical way. Consistently, you need to put your skills in more and more practical way. Keep practicing and learn from your mistakes is the best part to motivate yourself. You need to challenge yourself about what you've learned and keep updated about that skill. 

So, Guys above are the core steps according to me while dealing with online learning. You need to enhance these steps and divide according to your feasibility and suitability to your skills. Hope you like this blog. Thank you be safe and have a nice day.
C# : Avoid == && != to check for nullability
Tags: csharp, programming
Published: 2021-02-01 07:38:07

In everyday programming, we have to do something like the following because we don't want to see the ugly `NullReferenceException`

```csharp
var car = new Car();

if(car != null) 
{ 
    // invoke method on car variable 
}
```

Every programmer knows it's the right approach to avoid `NullReferenceException`. 

# But is it?

Interestingly enough, if we think about using `==` or `!=` it becomes apparent very quickly using these operators is not the proper way to check if a variable is null or not because, in C#, we have `operator overloading`. See the following example:

```csharp
public class Car
{
    public static bool operator ==(Car lhs, Car rhs) => true;

    public static bool operator !=(Car lhs, Car rhs) => !(lhs == rhs);
}
```
For this implementation we will have inappropriate results for null checking as demonstrated below:

```csharp
[Fact]
public void CSharp_Runtime_Should_Return_True_Provided_That_Variable_Is_Not_Null()
{
    var car = new Car();
   (car == null).ShouldBeTrue();
}

[Fact]
public void CSharp_Runtime_Should_Return_False_Provided_That_Variable_Is_Not_Null()
{
    var car = new Car();
   (car != null).ShouldBeFalse();
}
```

# Then what's the solution?

Use `is` & `is not` operator combination as shown below:

```csharp
[Fact]
public void CSharp_Runtime_Should_Return_False_Provided_That_Variable_Is_Not_Null()
{
    var car = new Car();
    (car is null).ShouldBeFalse();
}

[Fact]
public void CSharp_Runtime_Should_Return_True_Provided_That_Variable_Is_Not_Null()
{
    var car = new Car();
    (car is not null).ShouldBeTrue();
}
```

Use `is { }` expression as below:

```csharp
[Fact]
public void CSharp_Runtime_Should_Return_True_That_Variable_Is_Not_Null_Using_Property_Pattern_Matching()
{
    var car = new Car();
    (car is { }).ShouldBeTrue();
}

[Fact]
public void CSharp_Runtime_Should_Return_False_That_Variable_Is_Null_Using_Property_Pattern_Matching()
{
    Car car = null;
    (car is { }).ShouldBeFalse();
}
```

Note: `is { }` expression checks if the variable is an instance of `object`

Use `object.ReferenceEquals` `static` method as below:

```csharp
[Fact]
public void CSharp_Runtime_Should_Return_True_Provided_That_Variable_Is_Not_Null_Using_Reference_Equality_Check()
{
    var car = new Car();
    car.IsNotNull().ShouldBeTrue();
}

[Fact]
public void CSharp_Runtime_Should_Return_False_Provided_That_Variable_Is_Null_Using_Reference_Equality_Check()
{
    Car car = null;
    car.IsNotNull().ShouldBeFalse();
}

...
...
...

public static class ObjectExtensions
{
    public static bool IsNull<T>(this T obj) => ReferenceEquals(obj, null);

    public static bool IsNotNull<T>(this T obj) => !obj.IsNull();
}
```

Post inspiration: [How null checks have changed in C#](https://www.youtube.com/watch?v=lRUfRlp5BXc)
Urban Legend web design and development Whangarei Northland New Zealand
Tags: css, webdev, computerscience, tec
Published: 2021-02-01 07:28:47

Urban Legend web design and development Whangarei Northland New Zealand

Web Design and Development
Urban Legend web design Whangarei is based in Northland, New Zealand, and designs, codes, updates, and develops web sites.

Web Design …
We’re not from the web design school which packs in gizmos and whirling things just because we can.

We prefer to see and build web sites that are well-designed, yet clean, and fast-loading.  In other words, sites which are built for end users – simple enough to understand, navigate and enjoy, but designed well enough for those users to enjoy. We like to think this site, and most of those in our portfolio, meet those standards.

Site Development …
By web development we mean working with, or creating, an ‘engine’ which drives dynamic websites. The pre-packaged versions of these are commonly known as Content Management Systems, and can allow website owners to edit content, list and sell products, create an image gallery, run a subscription service, and more. All without knowing anything about how to web design. We also produce our own simple purpose-built ‘engines’.

cek this out :https://kilat.lezzat.id/update-3-best-completely-free-cloud-web-hosting-services-2020-kilat/

Hire us because …
We’re affordable. Many small-to-medium sized businesses, or clubs, don’t have bottomless pockets. We’ll give you a quote, not a fright, and stick to that figure.
We build web sites which load fast, and display reliably across a range of platforms and operating systems, thanks to the use of modern methods of coding to XHTML and CSS standards.

We build sites which look good.
Your site will be noticed. Our coding methods, and search engine knowledge give your website the best chance of being prominent in the relevant search engine results.
We focus on what’s important to you. For example, do you want your site to achieve a financial target, are you focussed on attracting new customers, or do you have a readership target you want to meet?

source :https://kilat.lezzat.id
What is the software testing life cycle?
Tags: softwaretesting, softwaretestinglifecycle
Published: 2021-02-01 07:21:37

"Software testing life cycle (STLC) is a test strategy that helps business achieves quality software. STLC is focused on testing the software by following different phases of the software testing process. To give you a clear understanding of STLC we have explained the whole software testing lifecycle in brief below:

What is the <a href="https://www.testingxperts.com/blog/types-of-software-testing">software testing life cycle</a>?
Software testing lifecycle is processes that have some steps that needed to be followed in sequence to ensure that software testing goals are met. In STLC each activity is carried out in a planned and systematic way to ensure that software testing goals are met.
 
What are the phases of the software testing lifecycle?
Below mentioned are the phases of the software testing lifecycle:
1.        Requirements phase – In this step, the requirement team analyses whether the requirements are testable or not. This helps to identify the scope of testing.

2.        Planning Phase – In this phase, teams plan the testing process and formulate strategy accordingly. Identification of activities, resources, and metrics is done in this step.  Risk analysis and risk mitigation are also done in this step. 

3.        Analysis phase – This phase defines ‘WHAT’ to be tested. Test conditions are identified through the requirements document, product risks, and other test bases.

4.        Design Phase –This phase defines the ‘HOW’ to test. In this phase the test condition is defined, test data is identified, the test environment is identified, test conditions are break into multiple sub-conditions to increase test coverage. 

5.        Implementation Phase- In this step the most critical process takes place, i.e.; test cases are identified, created, and prioritized. 

6.        Execution Phase- Test execution occurs during this phase. But before you conduct the test make sure that your entry criterion is met. Execute the test, log defects, and fill in your traceability metrics to track your progress. 

7.        Conclusion Phase –This phase focuses on exit criteria and reporting. Lay strong emphasis on reporting as it serves as a valuable piece of information for all involved stakeholders.

8.        Closure Phase- Check for the completion of the test and ensure that all the test cases are executed and mitigated deliberately. 
<a href="http://testingxperts.com/">Software testing</a> lifecycle follows a sequence of steps of the test following which the software can be tested robustly. Leverage software testing from a next-gen QA and software testing services provider to get high-quality software."
Day 1 - 66 Days of Data Science
Tags: devjournal
Published: 2021-02-01 07:15:38

For the 66 days of data science journey, I am going back to the basics and relearning statistics. I am using a textbook titled Introduction to The Practice of Statistics Sixth Edition - Moore, McCabe Craig. Here is what I learned so far.

Data are numbers with context. Before you do any statistical calculation and create data visualizations you need to start with the habit of forming a question. "What does the data tell me?"
The starting point to any statistical analysis is to master the art of examining data.

|Person   | Age  | Weight  
|---|---|---|---|---|
|Buttercup|  24 |110|   
|Bubbles| 24  |105|   
|Blossom| 24  |107|   


This is a table that contains data.

**Individuals** also known as cases, observations, and rows. If you are into programming you can think of rows as objects. Each object is like a noun that describes a (person, place, or thing). Objects have characteristics called variables.

**Variables** are also known as columns.

When you plan to do an exploratory data analysis(EDA) ask yourself the following questions.

1. Why? Is there a specific question that I want to be answered by looking at this data? What is the purpose of this data?

2. Who? What population does this data describe?

3. What? How many columns does this data set have? How are these variables defined?
Easily show a range/gauge with HTML <meter> element | Notes
Tags: notes, html
Published: 2021-02-02 11:43:28

---
title: Easily show a range/gauge with HTML <meter> element | Notes
published: true
date: 2021-02-01 06:40:00 UTC
tags: notes,html
canonical_url: https://abhi.page/notes/show-range-with-html-meter-element/
---

> **Direct Links:**
> - [developer.mozilla.org/en-US/docs/Web/HTML/Element/meter](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meter)

I really had no idea about the HTML `<meter>` element that can show a range of values, until I read [this tweet](https://twitter.com/IMAC2/status/1352603699944816645) by [Álvaro Trigo](https://twitter.com/IMAC2) 😃

### Example: [§](https://abhi.page/notes/show-range-with-html-meter-element/#example)

```
<meter min="0" max="100"	low="30" high="80" optimum="60"	value="70">
```


**Note:** The `<meter>` tag should not be used to show the progress of a task. For that, use the [`<progress> tag`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/progress).

* * *

[**Read on abhi.page**](https://abhi.page/notes/show-range-with-html-meter-element/) | [**Read more notes**](https://abhi.page/notes/)
How to log a node object with circular references to the console
Tags: node
Published: 2021-02-01 06:33:43

---
title: How to log a node object with circular references to the console
published: true
tags: #node
canonical_url: https://darraghoriordan.com/2021/01/17/how-to-log-node-object-to-console/
---

If you try to use `JSON.stringify()` on a NodeJS object you will get an error “Converting circular structure to JSON”. This is because NodeJS objects have circular references.

The way to stringify NodeJS objects is to use `util.inspect()`.

<!-- end excerpt -->
## util.inspect()

There is excellent documentation on the NodeJS site [here](https://nodejs.org/api/util.html#util_util_inspect_object_options).

But you can use it simply by just passing the object to the method without options.

```
util.inspect({ a: 1, b: 'b' })
```