teleren/devto huggingface dataset:
Extending Schematics in an Nx Plugin
Tags: nx, schematics, monorepo, webdev
Published: 2020-05-20 15:57:29

---
published: true
title: "Extending Schematics in an Nx Plugin"
cover_image:
description: "Build an Nx Plugin that extends a different libraries schematics"
tags: nx, schematics, monorepo, webdev
series:
canonical_url:
---

[Nx Plugins](https://nx.dev/nx-community) allow you to develop custom schematics for an Nx workspace, but maybe you just want to extend an existing set of schematics with some slight tweaks. [Schematics](https://angular.io/guide/schematics-authoring) feature this out of the box and it can be a good addition to your Nx Plugin.

For example, if your organization uses React and has a standard set of changes that are always made to new applications, but otherwise use the `@nrwl/react` schematics, you could extend the `@nrwl/react` schematics and customize only the `application` schematic. Any schematics other than the ones that have been overridden will fall back to the library that you have extended from.

## Implementation

Add an `extends` property in your plugins `collection.json` that contains an array of libraries you are overriding schematics from. Here is an example from my `@nxtend/ionic-react` Nx Plugin that overrides `@nrwl/react`:

```
{
  "$schema": "../../node_modules/@angular-devkit/schematics/collection-schema.json",
  "name": "ionic-react",
  "version": "0.0.1",
  "extends": ["@nrwl/react"],
  "schematics": {
    "init": {
      "factory": "./src/schematics/init/schematic",
      "schema": "./src/schematics/init/schema.json",
      "description": "Initialize the @nxtend/ionic-react plugin",
      "aliases": ["ng-add"],
      "hidden": true
    },

    "application": {
      "factory": "./src/schematics/application/schematic",
      "schema": "./src/schematics/application/schema.json",
      "aliases": ["app"],
      "description": "Create an Ionic React application"
    }
  }
}
```

In the example above, I override both the `init` and `application` schematic, but otherwise, all other schematics will fall back to `@nrwl/react`. That means that `nx g @nxtend/ionic-react:component` will fall back to `@nrwl/react:component` since the `component` schematic was not overridden above.

You may have noticed that the field is an array. This means that you can extend multiple schematics schematics to provide a wide variety of fallback commands that fit your needs.

## References

[Nx Plugin Guide](https://nx.dev/react/plugins/nx-plugin/overview)<br>
[Authoring Schematics by Angular](https://angular.io/guide/schematics-authoring)<br>
[@nxtend/ionic-react](https://github.com/devinshoemaker/nxtend/tree/master/libs/ionic-react)
WhackMIT
Tags: octograd2020
Published: 2020-05-20 15:55:08

[Comment]: # (All of this is placeholder text. Use this format or any other format of your choosing to best describe your project and experience.)

[Note]: # (If you used the GitHub Student Developer Pack on your project, add the "#githubsdp" tag above. We’d also love to know which services you used and how you used it!)

## My Final Project
At HackMIT 2019 last fall, my friends and I built "WhackMIT", a whimsical self-defense device that uses CV to detect if someone standing in front of you is scowling, and then whacks them with a pool noodle. We've had a [lot](https://devpost.com/software/troomba) of [fun](https://devpost.com/software/dre) creating goofy robots at hackathons we attend. I've learned the basics of prototyping physical robots/machines, and developing for Arduino/Raspberry Pi.

## Link to Code
{% github https://github.com/patil215/whackmit %}
[Note]: # (Our markdown editor supports pretty embeds. If you're sharing a GitHub repo, try this syntax: `{% github link_to_your_repo %}`)

## Additional Thoughts / Feelings / Stories
For the first half of the hackathon my sole role was as the "Raspberry Pi Engineer". Turns out getting a Raspberry Pi to talk over SSH is really hard with no monitor, no GPIO connector, and a noisy WiFi environment :joy:.

[Final Note]: # (CONGRATULATIONS!!! You are amazing!)
The Breakout [Catastrophe?] Project
Tags: octograd2020
Published: 2020-05-20 15:47:52

[Comment]: # (All of this is placeholder text. Use this format or any other format of your choosing to best describe your project and experience.)

[Note]: # (If you used the GitHub Student Developer Pack on your project, add the "#githubsdp" tag above. We’d also love to know which services you used and how you used it!)

## My Final Project
For my final few weeks in my programming class I recreated most of the game Breakout. [we were only taught the very basics of java, but luckily, you don't need someone to teach you something to learn it!] I didn't have enough time to finish it to my liking, we had about 36 hours total to work on it. My final code ended up not having a game win screen, nor a title screen. 

## Demo Link
 
You can download the [compiled jar here](https://github.com/linktlh/JavaBreakOut/releases). 

## Source Code
{% github linktlh/JavaBreakOut %}
[Note]: # (Our markdown editor supports pretty embeds. If you're sharing a GitHub repo, try this syntax: `{% github link_to_your_repo %}`)

## How I built it 
I over the progress of about 9 weeks, 4 hours each week; 1st planned out what I was going to do, then took that plan and wrote the code. Time efficiency was crucial due to the lack of time I had. In the small amount of time I got to learn about Timer, KeyBinds, and ActionListened (which kinda ties into the previous two). While my code may not be exactly pretty, I'm rather happy with the amount of progress I made in the short amount of time I had to work with.


## Additional Thoughts / Feelings / Stories
While creating the project, it went very smoothly. I created a rudimentary collisions system which worked exactly how I would imagine. However, once I started implementing horizontal movement.. that's where collisions went horrible. I originally had only been checking the bottom/top of the block, however, after adding x movement, I had to add checks for the left and right of the block. <strong>TO THIS DAY</strong> I have no clue how to properly implement collisions correctly. I spent a frustrating amount of time on collisions, having to throw things such as Titlescreen, and other features out the window due to time. I was always told that "collisions would be your nightmare", but I never understood that phrase until now. 

[Final Note]: # (CONGRATULATIONS!!! You are amazing!)
Git for Absolute Beginners
Tags: beginners, git, dev, tutorial
Published: 2020-05-20 15:44:32

---
title: Git for Absolute Beginners
published: true
description: If you are learning how to code, learning how to use git would become very useful and it's a tool that almost all software developer use. In this tutorial, I will clear some concepts for using git, how git works and will point you to a hands-on exercise where you can use git to make your first pull request.
tags: beginner, git, dev, tutorial
---
If you are learning how to code, learning how to use git would become very useful and it's a tool that almost all software developer use. In this tutorial, I will clear some concepts for using git, how git works and will point you to a hands-on exercise where you can use git to make your first pull request.

[Link to the sides](https://slides.com/cheukting_ho/what-is-git).

[Link to the exercise](http://bit.ly/1st_pr).
Manaculator
Tags: devgrad2020, octograd2020, showdev
Published: 2020-05-20 15:43:03

## What is it?

Manaculator is a simple, mobile-first interface for calculating ratios to help with land type distribution when drafting a Magic: The Gathering deck. By entering how many symbols of a given type are present in your deck, the manaculator will give a recommendation of how to distribute lands in your deck based on how many total lands you want in the deck!

Try out Manaculator at http://manaculator.surge.sh/ or view the repository below!

{% github https://github.com/AdnanSweeney/MTG-Mana-Calculator %}

## How I built it (what's the stack? did I run into issues or discover something new along the way?)

The Manaculator was built using React, CSS and some simple Javascript functionality.

One main issue along the way was dealing with an equal distribution of mana symbols present in the deck, but an odd number of total lands required. Lands in a deck must be dealt with in whole numbers, so at first I used rounding to deal with the messy math resulting in decimal values. This lead to incorrect land totals however, because if a 50-50 ratio occurred and we round up both 0.5 values, we have created a "required" land that didn't exist in our total number of lands! 

To deal with this I opted to provide more accurate, decimal values for users, but this proved to be more complicated to interpret from a user perspective. Eventually I was able to add in some more complex logic in the ratio calculator that would only allow one value to be rounded up, and the other to be rounded down. While the ratio itself may not be 100% accurate, this is much more user-friendly and more useful when drafting a deck.

Congrats to all the new grads out there!
Flipkart Automation
Tags: 2020devgrad, octograd2020, showdev, githubsdp
Published: 2020-05-20 15:38:22

---
title: Flipkart Automation
published: true
description: An automation testing project
tags: #2020devgrad, #octograd2020, #showdev, #githubsdp 
---
I just graduated from JIIT, Noida, India. I recently got placed at Cognizant, India, and also did an internship there. I worked on Automation Testing and my whole project is around Automation Testing using Selenium Web Driver. I learned several tools and libraries there such as TestNG, Selenium, Apache Maven, Git, Jenkins, etc, etc.

I met wonderful people during my internship and learned so much from them. In my project, I worked on writing bug reports, test cases, test scenarios, etc. Alongside writing reports, I also automated several test cases and executed them mainly focusing on Smoke and Regression Suite. 

Due to company policies, I am not able to share my code here.
Implementing Type Classes for Verifying Cryptography
Tags: security, functional
Published: 2020-05-20 15:31:02

My final year project existed at an interesting crossroads of programming languages and cryptography - the official title of which was "Programming Language Theory Applications for Verified Cryptography in EasyCrypt" which is by far a mouthful. In hindsight a more apt title would be "Type Classes for Verified Cryptography". 

The core focus of this project was work on a language called [EasyCrypt](easycrypt.info) which the maintainers describe as the following 

> EasyCrypt is a toolset for reasoning about relational properties of 
> probabilistic computations with adversarial code. Its main application
> is the construction and verification of game-based cryptographic proofs.

When we reference "game based cryptography" we are talking about models of security which when proven for a crypto-scheme highlight some behaviour i.e. what is the probability of correctly guessing a private key used for an encryption when you have access to an oracle that can perform encryption for you. The scope of EasyCrypt's functionality is vast and it has been used to prove a wide range of schemes in its time.

So what was my dissertation? Essentially EasyCrypt has a few limitations in terms of the expressivity of the language. One has to consider that languages like EasyCrypt allow us to verify crypto-schemes by allowing us to construct the schemes in the language and performing verification via the compiler. This construction is the real challenge that exists with any proof assistant; we require a language that is expressive as possible so that this translation from crypto-schemes (mathematics) to code is as easy as possible. My project was on implementing type classes - an idea popular in most functional programming languages - so that EasyCrypt's expressiveness could be extended. 

This project was arguably my most enjoyable throughout my time at university. A full copy of my dissertation can be accessed [here](https://nashpotato.github.io/2020/05/16/dissertation.html) which goes over all the nitty-gritty details.
My Experience Building A Python Project
Tags: octograd2020, devgrad2020, githubsdp, python
Published: 2020-05-20 15:28:42

## My Final Project:

FaceAttend - It's an attendance recording system that uses the power of facial recognition (through OpenCV) and marks attendance by detecting faces from the camera without redundantly capturing them more than once. It also has a feature that lets you see the analytical data of a particular student/class for determining the performance of either one.


## Link to Code:

{% github https://github.com/mayanxoni/FaceAttend %}


## How I built it (what's the stack? did I run into issues or discover something new along the way?):

I used Python 3.7.2 along with Qt for building it's beautiful GUI that helps it look more professional than it is. I thought it would be impossible for me to build a project under 4 months using a language that I thought was horrible but with the help of open-source content available on GitHub and open forums like Stackoverflow, I was able to pull it off easily.



## Additional Thoughts / Feelings / Stories:

I feel that building a solution using a particular language/stack should not matter as long as you think that the solution you're building itself is a life-changing product.


[Final Note]: # (CONGRATULATIONS!!! You are amazing!)
Code Together, Debug Together with CodeAssist
Tags: octograd2020
Published: 2020-05-20 15:27:31

[Comment]: # (All of this is placeholder text. Use this format or any other format of your choosing to best describe your project and experience.)

[Note]: # (If you used the GitHub Student Developer Pack on your project, add the "#githubsdp" tag above. We’d also love to know which services you used and how you used it!)

## CodeAssist
It is a platform for collaborative coding (real-time changes to a shared code), along with compilation (with test cases optionally) and compilation errors, and fetches the first result on Google for that error. A chatbot, making friends and one-to-one chatting is also implemented.

## Demo Link
Currently not deployed for the world, but you can deploy it yourself, and check it out!

## Link to Code
{% github https://github.com/Lasers67/CodeAssist %}
[Note]: # (Our markdown editor supports pretty embeds. If you're sharing a GitHub repo, try this syntax: `{% github link_to_your_repo %}`)

## How we built it
We decided to use a good fast server-side language, so Node.JS was the most favourable. Then to store data, since I was familiar with MySQL, we took it up, to ease the DB part. Express is used to render pages, and a judge API to get the results of compilation and program run. Also, the chatbot is implemented using [api.ai](https://api.ai).

## Additional Thoughts / Feelings / Stories
This project was basically made for our course work. We originally decided to make something easy and be done with it :p, but one of us got this good idea (kudos [Lasers67](https://github.com/Lasers67)!) and we thought let's make something fun and interesting. It took a lot of hard work and toil (we had the first encounter with Node.JS!), but we are proud of it!


[Final Note]: # (CONGRATULATIONS!!! You are amazing!)
Space Cats!
Tags: octograd2020, videogame, 3d, action
Published: 2020-05-20 15:26:12

# What is it?
Space Cats! is a 3D On-Rails Space-Shooter Action game. It features engaging combat, a fun story, and yes, stock photos of cats!

# Screenshots
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/l86g8brtdo65443qupht.png)
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/jsicn7s8tkneaxm7bpyg.png)
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/jcmrec2a03yj69o4f38w.png)

## Webpage and Demo Link ( 64bit Windows/MacOS/Linux)
https://notoriouseng.itch.io/space-cats

## Link to Code (Code Only, no Assets/Unity files)
https://github.com/NotoriousENG/SpaceCats/tree/master/Scripts

# What I Did:
I developed this game with my friend Wilson for our
Senior Project. We used Unity and C#. We had about 4 weeks for preproduction and 12 weeks of active development. Since our team was so small we each had the opportunity to work on almost every aspect of the game. I worked on creating Movement, Combat, AI, UI, Dialogue, the final boss encounter, and more.

# Challenges and Solutions:
Without going to in depth, we had a lot of systems to create in a very limited amount of time. We took our preproduction time very seriously and worked out how everything should look and the technical specifications that would have to be met way before committing to anything. We would aim to make all of our classes as polymorphic as possible and instead of creating complex AI, would create simple responses that could be combined to create emergent behavior. I will link a very detailed postmortem below.

# What's Missing / Lessons Learned
Since this project focused on mechanics, we did not have enough time to develop the artistic side of our game. We also had to make the decision to allow our player to phase through objects when taking damage in our cinematic level, this was because colliding with static objects would break our camera system and disorient the player which we didn’t notice until late in development.

We believe that upon further iteration, we could keep improving our game’s mechanics and aesthetics and eventually create a commercially viable product. We would also have to develop more levels, expand gameplay possibilities, and create custom art assets.

## Postmortem
https://michaeljoconnell.weebly.com/uploads/9/2/8/0/92808070/space_cats_-_final_report.pdf
QnA Web Platform
Tags: java, springboot, githubsdp, postgres
Published: 2020-05-20 15:22:04

- I have recently been practicing backend development using Spring framework.
- The project is capable of handling CRUD Operations, Exception Handling, Authentication and Authorization.
- I developed REST Endpoints, web pages and much more.
- Link to code - https://github.com/abhinavg916/Quora-backend
- I look forward to suggestions and improvements :)
Wunner
Tags: octograd2020, devgrad2020
Published: 2020-05-20 15:21:24

## Wunner
Wunner is a simple terminal-based web search engine I built to understand the basic working of a search engine.

## Link to Code
{% github https://github.com/Anishka0107/Wunner %}

## How I built it
It is purely written in C++14. It crawls webpages progressively starting from seed URL(s). Then it pre-processes the documents and builds an index for the parsed documents. The crawled documents and index are refreshed periodically. It autocompletes query using a trie, based on most recently asked queries. It generates the most relevant results in order ranked on the basis of harmonic mean of PageRank (to get the importance of a webpage) and Okapi BM25 (to get query-based results) algorithm ranks. It also provides query suggestions when the input query does not generate any results, on the basis of common incorrect and correct words (ranked using n-gram algorithm and edit-distance).


## Additional Thoughts / Feelings / Stories
It was fun developing this project as it was built from scratch and allowed me to learn about different data structures and use them practically.

Final Note: Stay healthy, stay safe!
[Cloud DevOps Engineer Capstone Project]
Tags: octograd2020
Published: 2020-05-20 15:18:19

# Cloud-DevOps-Engineer-Capstone-Project

In this project, I have created a CICD pipeline as my Capstone project of the Udacity Cloud DevOps Nano Degree.

## Project Requirements

* AWS Account
* Jenkins Server
* Docker Hub account
* Docker
* Kubernetes
* Ansible
* eksctl and kubectl

## Project Tasks:

* Working on AWS Cloud Platform
* CICD pipeline on Jenkins
* Building Docker image
* Push Docker image to the Docker Hub
* Deploy EKS cluster with Ansible playbook
* Deploying Docker image to the cluster

## Project Architecture

![CI/CD Pipeline](https://raw.githubusercontent.com/prateekjaindev/Cloud-DevOps-Engineer-Capstone-Project/master/ScreenShots/CICI%20Pipeline.png)

## Project Files

https://github.com/prateekjaindev/Cloud-DevOps-Engineer-Capstone-Project
Github Graduation : The New Way Forward
Tags: octograd2020, githubsdp
Published: 2020-05-20 15:10:47

**My Project as a student was to Update Ghost Blogging Platform to Work on  Heroku**

[Note]: # (If you used the GitHub Student Developer Pack on your project, add the "#githubsdp" tag above. We’d also love to know which services you used and how you used it!)

## My Final Project
I was looking for a Platform to Blog and was searching though options and found ghost with features memberships, headless CMS

This isn't a individual Project from Scratch but i like this then other projects because of the core blogging platform it uses [Ghost](https://ghost.org). 
Ghost provides simplicity, superiority and security over other options , and its feature full unlike those other programs which are hard to Deploy and dosen't have much functions

I enjoyed the whole journey.

## Demo Link
https://ghost-blog-eu.herokuapp.com/

## Link to Code
{% github https://github.com/abhay-ranawat/ghost-on-heroku %}

[Note]: # (Our markdown editor supports pretty embeds. If you're sharing a GitHub repo, try this syntax: `{% github https://github.com/abhay-ranawat/ghost-on-heroku %}`)

## How I built it (what's the stack? did I run into issues or discover something new along the way?)
We Will use github to Store and Deploy Code to Heroku. Sendgrid will be used as base mailing Platform Mailgun will be used for mailing to membership features and Heroku will be used to Host The Platform

Well, those were the days when I slowly started developing my interest in the field of web development.
It uses **Node JS** so Knowing JavaScript and **NPM** is Basic and also about architecture and Deploying is also Very Must
Node is Beautiful Language and the Recent acquisition of **NPM** by **Github** also look a better Setp

## Additional Thoughts / Feelings / Stories

Github Education Was Very Useful and The Resources used in this project are:

1. Github 
2. Heroku Students Pack
3. SendGrid/Mailgun


[Final Note]: # (CONGRATULATIONS!!! You are amazing!)
Arduino Reaction Time Test
Tags: octograd2020, devgrad2020
Published: 2020-05-20 14:11:24

## My Project
The project that I recently worked on is a reaction time test made by using an Arduino. It works like so:

1. Press the start button to begin.
2. Now a randomly generated number will appear on the screen; the task is to press the corresponding button as quickly as possible, as it will be timed.
3. This will be repeated 10 times and in the end, the user will see their average and total reaction time.

<i>P.S. If you press the right button you will hear a snippet of the GTA San Andreas theme song, but if you press the wrong one you will hear a part of Beethoven's Symphony No. 5. In the end, if you pressed all 10 buttons correctly you will hear a longer version of the soundtrack and thus be praised as the winner!</i>

## Link to Code
{% github https://github.com/dragmakex/ReactionTime %}

## How I built it
I used the Arduino starter kit provided by our school. The modules that I used were the circuit board, speaker, an LCD and of course the Arduino microcontroller.

## Conclusion
I have never worked with electronics before, so I had lots of fun connecting all the modules and trying out different things! I will definitely buy more parts in the future to work on bigger projects.