This is a Jekyll site using Git as a CMS. It was created with Stackbit in under a minute.

You can create a site just like this one, or explore some variations. How about a different:

1. Install a full Ruby development environment

2. Install Jekyll and Bundler:

    gem install jekyll bundler
   

3. Install dependencies from Gemfile:

    bundle install
   

4. Build the site and start the Jekyll local development server

    bundle exec jekyll serve --livereload
   

5. Open http://localhost:4000 in the browser

6. 🎉

To start editing your site, you can edit the included Markdown files.

Alternatively, you can use the free on-page editing experience provided by the Stackbit Studio.

Here’s a few resources to get you started:

• 📺   Editing Content
• 📺   Adding, Reordering and Deleting Items
• 📺   Collaboration
• 📺   Publishing
• 📚   Stackbit Documentation

If you need a hand, make sure to check the Stackbit support page.

Generated at 2021-01-03T17:43:38.120Z by Stackbit version 0.3.42.

Knowing that is possible to write a class which implements one or multiple simple interfaces,
even if those interfaces have one or more common methods in their contracts
(and in this case we only need to provide a single implementation),
once i was introduced to interfaces with default method implementation i questioned what happens if we try to write a class
which implements two interfaces that both have a default implementation for the same method signature.

In the example i provide in this repo i have two interfaces InterfaceA & InterfaceB
which basically have two methods:

• a default method void whereAmI(), that prints a simple string to help us understard which of the two default implementation is taken into consideration;
• and a method void otherMethod() just to confirm what is being said in the abstract.

Then i have a class Test that implements the two interfaces and has a blank implementation of otherMethod().
Finally a Main class to make use of the Test class.
For sake of semplicity i didn’t organize the code in packages or inside of a src folder

I tought that the implementation that would be taken into consideration was choosen based on the order in which i declare that class Test implements InterfaceA and InterfaceB, but in reality what i get is a compilation error:

Test.java:1: error: types InterfaceA and InterfaceB are incompatible;
public class Test implements InterfaceA, InterfaceB {

class Test inherits unrelated defaults for whereAmI() from types InterfaceA and InterfaceB
1 error

In this capstone, I predicted if the Falcon 9 first stage will land successfully. SpaceX advertises Falcon 9 rocket launches on its website with a cost of 62 million dollars; other providers cost upward of 165 million dollars each, much of the savings is because SpaceX can reuse the first stage. Therefore determining if the first stage will land and the cost of launch can help to determine if an alternate company may want to bid against SpaceX for a rocket launch. In this lab, I completed several stesp:

• I collected data from an API and wrangled it into the right format
• I gathered additional supplemental data via webscraping
• I utilized a SQL database and Python/Juptyer Notebooks to perform EDA.
• I created a number of useful visualizations
• I employed Folium as a way to visualize launch sites and landmarks
• I created a dashboard with Dash and Plotly for stakeholder use
• I set up ML models to predict launch success and performed some feature engineering as well
• I created a written report summarizing our findings and recommendations.

Programming, Python, RDBMS & SQL, SQL (MySQL), Databases, Statistics, Probability, Linear Algebra, Numpy, Pandas, Seaborn, Matplotlib, Plotly, Dash, Folium, BeautifulSoup, Scikit-learn, Dataframes, ETL &| ELT & Data Pipelines, Automation, Webscraping, APIs, Data Modeling, EDA, Data Visualization, Data Summarization, Data Reporting, Dashboards, Classification, Supervised ML, Communication, Technical Writing

This repository contains an attempt to faithfully translate the Elligator 2 implementation in Loup Vaillant’s Monocypher to OCaml. Loup Vaillant was instrumental to the successful porting effort through his help and observations, and deserves a great thanks for helping make this possible.

Elligator 2 provides a mapping from x25519 public key (curve points) to bitstrings indistinguishable from uniformly random 256-bit bitstrings.

NB: Currently requires pinning opam pin add mirage-crypto-ec https://github.com/cfcs/mirage-crypto#raw_scalarmult

The main API entry points are:

val crypto_curve_to_hidden : Z.t -> int -> string
(** [crypto_curve_to_hidden point tweak] is the Elligator representative (aka encoding)
    of [point], "tweaked" with [tweak] whose lower 8 bits should be
    randomly chosen:
    - the LSB of [tweak] is used to select negation of [point]
    - the two MSB of [tweak] cast to a uint8 (bits 6 and 7, selected with & 0xc0) are used as padding of the two MSB of the little-endian representation of the representative.
*)

val crypto_hidden_to_curve : string -> Z.t
(** [crypto_hidden_to_curve representative] is the point corresponding to [representative].
    Any random 256-bit string can be provided as [representative].
    The tweak is not currently recovered.
*)

Inspired by dsaltares/fetch-gh-release-asset GitHub Action and several others, this action downloads all assets from a Release, without needing to build a Docker container.

This results in a faster job execution, since GitHub Actions Runner will execute the JavaScript code directly. 🙂

name: ci

on:
  push:
    branches:
      - 'master'
    tags:
      - 'v*'

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Download release dependencies
        uses: duhow/download-github-release-assets@v1
        with:
          token: ${{ secrets.PAT_TOKEN }}
          repository: actions/runner
          tag: v2.282.1
          files: actions-runner-linux-x64-*.tar.gz
          target: apps/actions-runner.tar.gz
      - name: Extract
        run: |
          tar xzvf apps/actions-runner.tar.gz

Optional GitHub Token to authenticate as. Defaults to ${{ secrets.GITHUB_TOKEN }}

The org/repo containing the release. Defaults to the current repository.

The Release ID version to fetch. If no tag is specified, defaults to latest release.

The Git tag name to fetch the release from.

Required The name of the file/s to download as a list, or single file. If files is set to '*', all assets are downloaded.
You can use * wildcard to select a file pattern.

files: |
  config.json
  program-*.exe

Target file path. If several files are specified, this is the folder to download the files (recursive folders will be created if don’t exist). If files contains a single file, this is the full path to download the file (recursive folders will be created).

Set to false if you do not want to download files, output assets still will contain selected files.

The title / name of the selected release.

The description / body of the selected release.

The Git tag value of the selected release. Useful to attempt knowing the version if you selected latest.

List of full path assets downloaded.

See English version below.

This is the jekyll theme used for my personal Persian website. Persian aka Farsi is written right-to-left, however some people use Roman script to write Persian language in messaging applications and social networks.

During the last few years people have reached out to me asking how to setup a persian Jekyll website with Jalali calendar support. Since Jekyll now supports themes, I created this theme based on my website to help others to bootstrap their own websites.

This repository can be of use to anybody willing to build a new right to left website. I gradually fix issues which I came across while writing new posts in my website. This website is produced using Jekyll static site generator.

Take the following steps to make your own website based on this theme. First of all, create your website if you have not already:

$ jekyll create mywebsite

Then add this line to your Jekyll site’s Gemfile:

gem "jekyll-theme-mehdix-rtl", "~> 3.0"

And add this line to your Jekyll site’s _config.yml:

theme: jekyll-theme-mehdix-rtl

And then execute:

$ bundle install

Or install it yourself as:

$ gem install jekyll-theme-mehdix-rtl

You can override theme style by creating matching files with the same structure inside your Jekyll source tree. See Jekyll Themes docs for more information on that.

You can create a _sass folder and put a file named custom.scss in it. This theme will load it by default.

The following layouts are available for your homepage:

• home: post titles along with an excerpt and pagination
• minimal: only post titles

This theme supports three comment systems. First one is disqus. In order to enalbe disqus comments add comment_system:disqus and disqus_shortname:DISQUS_USERNAME to your _config.yml file.

The second approach is static comments. In order to enable static comments add comment_system:static to the config file. This will load commends from _data/comments folder. There should be one YAML file per post. Name of the file should be the uuid of the post (each post must have a uuid in its front matter). The following sample defines two comments for post with uuid 0b64d07f-6c08-475b-a509-463df5458039:

- date: 20171220
  name: تقی
  email: john@doe.com
  url: https://johndoe.com
  text: >
      نوکرتم دادا!
      کوجایی تو؟

- date: 20171221
  name: تقی ۲
  email: john@doe.com
  url: https://johndoe.com
  text: >
      [۲] دادا خبری نیت ازت

For the time being I am using Netlify to handle custom comment forms on each post page and add them to the comments using the netlify_comments.py script.

If you put code blocks and they appear incorrectly, you can use Markright gem. First add it to your Gemfile:

gem "jekyll-markright"

And change your config.yml respectively:

markdown: Markright

If any of the following ids is present in the config a corresponding item will be added to the footer:

• github_username
• twitter_username
• feedburner_id
• email

In order to send pageviews to Google Analytics set your ID in the _config.yml: google_analytics_id: YOUR_ID

Make sure to fill entries in the config file correctly to get a better search engine experience. Specially fill the SEO section with your Github and Twitter usernames. Don’t forget to add lang and logo entries. See jekyll-seo-tag for further information.

MIT

<div dir="rtl" lang="fa">مطلب مورد نظر</div>

Demo application for FreeMarker Native project, based on Quarkus.

Requirements :

• GraalVM 21+

1. Build

./gradlew build -Dquarkus.native.enabled=true -Dquarkus.package.jar.enabled=false

2. Run

./build/freemarker-native-demo-*-runner 

3. Test

http://localhost:8080/hello/freemarker

There are the operations we did to configure this project native build :

1. Added dependency “org.fugerit.java:freemarker-native”
2. Configured additional build args -H:IncludeResources
3. Configured reflection for beans (with annotation @RegisterForReflection)

From here on you can find the README generated from the Quarkus Launcher :

https://code.quarkus.io/?g=org.fugerit.java.demo&a=freemarker-native-demo&b=GRADLE_KOTLIN_DSL&e=rest

This project uses Quarkus, the Supersonic Subatomic Java Framework.

If you want to learn more about Quarkus, please visit its website: https://quarkus.io/.

You can run your application in dev mode that enables live coding using:

./gradlew quarkusDev

NOTE: Quarkus now ships with a Dev UI, which is available in dev mode only at http://localhost:8080/q/dev/.

The application can be packaged using:

./gradlew build

It produces the quarkus-run.jar file in the build/quarkus-app/ directory. Be aware that it’s not an über-jar as the dependencies are copied into the build/quarkus-app/lib/ directory.

The application is now runnable using java -jar build/quarkus-app/quarkus-run.jar.

If you want to build an über-jar, execute the following command:

./gradlew build -Dquarkus.package.jar.type=uber-jar

The application, packaged as an über-jar, is now runnable using java -jar build/*-runner.jar.

You can create a native executable using:

./gradlew build -Dquarkus.native.enabled=true -Dquarkus.package.jar.enabled=false

Or, if you don’t have GraalVM installed, you can run the native executable build in a container using:

./gradlew build -Dquarkus.native.enabled=true -Dquarkus.native.container-build=true -Dquarkus.package.jar.enabled=false

You can then execute your native executable with: ./build/freemarker-native-demo-1.0.0-SNAPSHOT-runner

If you want to learn more about building native executables, please consult https://quarkus.io/guides/gradle-tooling.

• REST (guide): A Jakarta REST implementation utilizing build time processing and Vert.x. This extension is not compatible with the quarkus-resteasy extension, or any of the extensions that depend on it.

Easily start your REST Web Services

Related guide section…

Project dependencies and setup

• Xcode 8
• Swift 3
• ————
• Alamofire (HTTP networking lib)
• Unbox (Swift JSON decoder)
• UnboxedAlamofire (Custom Response Serializer for Unbox)
• AlamofireImage (Image response serializer for Alamofire)
• SnapKit (Swift Autolayout DSL)
• —————
• Git git clone git@github.com:salomoko/InspiratoSearchExercise.git
• Cocoapods (1.1.1) – pod install

This basic example came from a coding exercise I did while interviewing for an iOS Developer position at Inspirato

The reason I made this exercise a public repo is not to provide other candidates that may not be qualified a solution, but rather to provide an example of using Unbox with Alamofire in Swift 3! Plus I had fun doing it!

IMO I think this is a very simple/clean solution to a very common task iOS developers face regularly. The serialization is handled very nicely as property types are automatically detected and decoded. All missing or mismatched values are gracefully handled through a single exception type, making error handling super simple!
Your models aren’t saturated with optional properties, that you later have to unwrap, guard or add more LOC at some point.
And best of all its a light weight solution that you can use with your protocol oriented swift apps!

This example is simply meant to critique and/or get ideas off of. I ended up NOT receiving an offer from them, stating something along the lines of your code was very elegant and clean but it didn’t touch on the areas they were looking for. Whatever that means, I’m assuming because I failed to implement AutoLayout on a couple screens, simply spaced it!

This application was generated using JHipster 4.12.0, you can find documentation and help at http://www.jhipster.tech/documentation-archive/v4.12.0.

Before you can build this project, you must install and configure the following dependencies on your machine:

1. Node.js: We use Node to run a development web server and build the project.
   Depending on your system, you can install Node either from source or as a pre-packaged bundle.
2. Yarn: We use Yarn to manage Node dependencies.
   Depending on your system, you can install Yarn either from source or as a pre-packaged bundle.

After installing Node, you should be able to run the following command to install development tools.
You will only need to run this command when dependencies change in package.json.

yarn install

We use yarn scripts and Webpack as our build system.

Run the following commands in two separate terminals to create a blissful development experience where your browser
auto-refreshes when files change on your hard drive.

./mvnw
yarn start

Yarn is also used to manage CSS and JavaScript dependencies used in this application. You can upgrade dependencies by
specifying a newer version in package.json. You can also run yarn update and yarn install to manage dependencies.
Add the help flag on any command to see how you can use it. For example, yarn help update.

The yarn run command will list all of the scripts available to run for this project.

Service workers are commented by default, to enable them please uncomment the following code.

• The service worker registering script in index.html

<script>
    if ('serviceWorker' in navigator) {
        navigator.serviceWorker
        .register('./sw.js')
        .then(function() { console.log('Service Worker Registered'); });
    }
</script>

Note: workbox creates the respective service worker and dynamically generate the `sw.js`

### Managing dependencies

For example, to add [Leaflet][] library as a runtime dependency of your application, you would run following command:

    yarn add --exact leaflet

To benefit from TypeScript type definitions from [DefinitelyTyped][] repository in development, you would run following command:

    yarn add --dev --exact @types/leaflet

Then you would import the JS and CSS files specified in library's installation instructions so that [Webpack][] knows about them:
Edit [src/main/webapp/app/vendor.ts](src/main/webapp/app/vendor.ts) file:
~~~
import 'leaflet/dist/leaflet.js';
~~~

Edit [src/main/webapp/content/css/vendor.css](src/main/webapp/content/css/vendor.css) file:
~~~
@import '~leaflet/dist/leaflet.css';
~~~
Note: there are still few other things remaining to do for Leaflet that we won't detail here.

For further instructions on how to develop with JHipster, have a look at [Using JHipster in development][].

### Using angular-cli

You can also use [Angular CLI][] to generate some custom client code.

For example, the following command:

    ng generate component my-component

will generate few files:

    create src/main/webapp/app/my-component/my-component.component.html
    create src/main/webapp/app/my-component/my-component.component.ts
    update src/main/webapp/app/app.module.ts

### Doing API-First development using swagger-codegen

[Swagger-Codegen]() is configured for this application. You can generate API code from the `src/main/resources/swagger/api.yml` definition file by running:
```bash
./mvnw generate-sources

Then implements the generated interfaces with @RestController classes.

To edit the api.yml definition file, you can use a tool such as Swagger-Editor. Start a local instance of the swagger-editor using docker by running: docker-compose -f src/main/docker/swagger-editor.yml up -d. The editor will then be reachable at http://localhost:7742.

Refer to Doing API-First development for more details.

To optimize the lookbrbackendv2 application for production, run:

./mvnw -Pprod clean package

This will concatenate and minify the client CSS and JavaScript files. It will also modify index.html so it references these new files.
To ensure everything worked, run:

java -jar target/*.war

Then navigate to http://localhost:8080 in your browser.

Refer to Using JHipster in production for more details.

To launch your application’s tests, run:

./mvnw clean test

Unit tests are run by Karma and written with Jasmine. They’re located in src/test/javascript/ and can be run with:

yarn test

UI end-to-end tests are powered by Protractor, which is built on top of WebDriverJS. They’re located in src/test/javascript/e2e
and can be run by starting Spring Boot in one terminal (./mvnw spring-boot:run) and running the tests (yarn run e2e) in a second one.

Performance tests are run by Gatling and written in Scala. They’re located in src/test/gatling and can be run with:

./mvnw gatling:execute

For more information, refer to the Running tests page.

You can use Docker to improve your JHipster development experience. A number of docker-compose configuration are available in the src/main/docker folder to launch required third party services.

For example, to start a mysql database in a docker container, run:

docker-compose -f src/main/docker/mysql.yml up -d

To stop it and remove the container, run:

docker-compose -f src/main/docker/mysql.yml down

You can also fully dockerize your application and all the services that it depends on.
To achieve this, first build a docker image of your app by running:

./mvnw verify -Pprod dockerfile:build

Then run:

docker-compose -f src/main/docker/app.yml up -d

For more information refer to Using Docker and Docker-Compose, this page also contains information on the docker-compose sub-generator (jhipster docker-compose), which is able to generate docker configurations for one or several JHipster applications.

To configure CI for your project, run the ci-cd sub-generator (jhipster ci-cd), this will let you generate configuration files for a number of Continuous Integration systems. Consult the Setting up Continuous Integration page for more information.

Demo Video of Project

😥 Tired of managing student attendance with paper and spreadsheets?

The Mbm Attendance Application is here to streamline the process!😀

This project is an attendance management application developed for MBM UNIVERSITY as a part of the Minor Project. The application aims to streamline the process of tracking and managing student attendance efficiently.

• User Authentication: Secure user authentication system for students and faculty members.
• Dashboard: Intuitive dashboard for easy navigation and access to attendance-related functionalities.
• Mark Attendance: Faculty members can mark attendance for their respective classes.
• View Attendance: Students can view their attendance records for individual subjects.
• Attendance Reports: Generate detailed reports of attendance for specific periods or subjects.
• Notifications: Automated notifications for absentees and low attendance percentages.

• Frontend: HTML, CSS, JavaScript, ReactJs, vite
• Backend: Node.js, Express.js
• Database: MySQL
• Authentication: JSON Web Tokens (JWT)

• Node.js (v20.11): You can use the package manager of your choice. Tests need to pass in Node 20 and 22.

1. Clone the repository:   git clone https://github.com/aakashsharma003/Mbm-Attendance-Application.git

2. Install dependencies: Run the below two commands in 2 different terminal

3. backend   cd Mbm-Attendance-Application cd backend npm install

4. frontend  cd Mbm-Attendance-Application cd frontend npm install

5. Set up environment variables:

• Create a `.env` file in the backend directory.
• Add the following environment variables:

PORT=8000
DB_HOST="localhost"
DB_USERNAME="your_username"
DB_DBNAME="your_db_name"
DB_PASSWORD="your_password"

4. Run the application:

• run the command in both frontend & backend npm run dev

5. Access the application backend in your browser at http://localhost:8000 & frontend at http://localhost:5173.

Contributions are welcome! If you find any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request.

This project is licensed under the MIT License – see the LICENSE file for details.

Additional Notes

• For development mode specific instructions (e.g., compiling assets, starting a development server), refer to the project documentation (if available).
• Deployment instructions can be added if the application is designed to be deployed on a server.
• Consider adding screenshots showcasing the application’s functionalities.