GitHub 1C Enterprise Daily Trending

ZachGoldberg/Startup-CTO-Handbook

2023-10-25T01:23:20Z

A Q&A platform software for teams at any scales. Whether it's a community forum, help center, or knowledge management platform, you can always count on Answer.

Answer - Build Q&A platform

A Q&A platform software for teams at any scales. Whether it’s a community forum, help center, or knowledge management platform, you can always count on Answer.

To learn more about the project, visit answer.dev.

Screenshots

Quick start

Running with docker

docker run -d -p 9080:80 -v answer-data:/data --name answer answerdev/answer:latest

For more information, see Installation

Plugins

Answer provides a plugin system for developers to create custom plugins and expand Answer’s features. You can find the plugin documentation here.

We value your feedback and suggestions to improve our documentation. If you have any comments or questions, please feel free to contact us. We’re excited to see what you can create using our plugin system!

You can also check out the plugins here.

Contributing

Contributions are always welcome!

See CONTRIBUTING for ways to get started.

License

Apache License 2.0

eureka-research/Eureka

2023-10-25T01:23:20Z

Official Repository for "Eureka: Human-Level Reward Design via Coding Large Language Models"

Eureka: Human-Level Reward Design via Coding Large Language Models

[Website] [arXiv] [PDF]

https://github.com/eureka-research/Eureka/assets/21993118/1abb960d-321a-4de9-b311-113b5fc53d4a

Large Language Models (LLMs) have excelled as high-level semantic planners for sequential decision-making tasks. However, harnessing them to learn complex low-level manipulation tasks, such as dexterous pen spinning, remains an open problem. We bridge this fundamental gap and present Eureka, a human-level reward design algorithm powered by LLMs. Eureka exploits the remarkable zero-shot generation, code-writing, and in-context improvement capabilities of state-of-the-art LLMs, such as GPT-4, to perform in-context evolutionary optimization over reward code. The resulting rewards can then be used to acquire complex skills via reinforcement learning. Eureka generates reward functions that outperform expert human-engineered rewards without any task-specific prompting or pre-defined reward templates. In a diverse suite of 29 open-source RL environments that include 10 distinct robot morphologies, Eureka outperforms human expert on 83% of the tasks leading to an average normalized improvement of 52%. The generality of Eureka also enables a new gradient-free approach to reinforcement learning from human feedback (RLHF), readily incorporating human oversight to improve the quality and the safety of the generated rewards in context. Finally, using Eureka rewards in a curriculum learning setting, we demonstrate for the first time a simulated five-finger Shadow Hand capable of performing pen spinning tricks, adeptly manipulating a pen in circles at human speed.

Installation

Eureka requires Python ≥ 3.8. We have tested on Ubuntu 20.04 and 22.04.

Create a new conda environment with:

conda create -n eureka python=3.8
conda activate eureka

Install IsaacGym (tested with Preview Release 4/4). Follow the instruction to download the package.

tar -xvf IsaacGym_Preview_4_Package.tar.gz
cd isaacgym/python
pip install -e .
(test installation) python examples/joint_monkey.py

Install Eureka

git clone https://github.com/eureka-research/Eureka.git
cd Eureka; pip install -e .
cd isaacgymenvs; pip install -e .
cd ../rl_games; pip install -e .

Eureka currently uses OpenAI API for language model queries. You need to have an OpenAI API key to use Eureka here/. Then, set the environment variable in your terminal

export OPENAI_API_KEY= "YOUR_API_KEY"

Getting Started

Navigate to the eureka directory and run:

python eureka.py env={environment} iteration={num_iterations} sample={num_samples}

{environment} is the task to perform. Options are listed in eureka/cfg/env.
{num_samples} is the number of reward samples to generate per iteration. Default value is 16.
{num_iterations} is the number of Eureka iterations to run. Default value is 5.

Below are some example commands to try out Eureka:

python eureka.py env=shadow_hand sample=4 iteration=2 model=gpt-4-0314

python eureka.py env=humanoid sample=16 iteration=5 model=gpt-3.5-turbo-16k-0613

Each run will create a timestamp folder in eureka/outputs that saves the Eureka log as well as all intermediate reward functions and associated policies.

Other command line parameters can be found in eureka/cfg/config.yaml. The list of supported environments can be found in eureka/cfg/env.

Eureka Pen Spinning Demo

We have released Eureka pen spinning policy in isaacgymenvs/isaacgymenvs/checkpoints. Try visualizing it with the following command:

cd isaacgymenvs/isaacgymenvs
python train.py test=True headless=False force_render=True task=ShadowHandSpin checkpoint=checkpoints/EurekaPenSpinning.pth

Note that this script use the default Isaac Gym renderer and not the Omniverse rendering in the paper videos.

Running Eureka on a New Environment

Create a new IsaacGym environment; instructions can be found in here.
Verify that standard RL works for your new environment.

cd isaacgymenvs/isaacgymenvs
python train.py task=YOUR_NEW_TASK

Create a new yaml file your_new_task.yaml in eureka/cfg/env:

env_name: your_new_task
task: YOUR_NEW_TASK 
description: ...

Construct the raw environment code that will serve as context for Eureka as well as the skeleton environment code on which the Eureka reward will be appended to:

cd eureka/utils
python prune_env.py your_new_task

Try out Eureka!

python eureka.py env=your_new_task

Acknowledgement

We thank the following open-sourced projects:

Our environments are from IsaacGym and DexterousHands.
Our RL training code is based on rl_games.

License

This codebase is released under MIT License.

Citation

If you find our work useful, please consider citing us!

@article{ma2023eureka,
  title   = {Eureka: Human-Level Reward Design via Coding Large Language Models},
  author  = {Yecheng Jason Ma and William Liang and Guanzhi Wang and De-An Huang and Osbert Bastani and Dinesh Jayaraman and Yuke Zhu and Linxi Fan and Anima Anandkumar},
  year    = {2023},
  journal = {arXiv preprint arXiv: Arxiv-2310.12931}
}

Disclaimer: This project is strictly for research purposes, and not an official product from NVIDIA.

Significant-Gravitas/AutoGPT

2023-10-25T01:23:20Z

An experimental open-source attempt to make GPT-4 fully autonomous.

🌟 AutoGPT: the heart of the open-source agent ecosystem

AutoGPT is your go-to toolkit for supercharging agents. With its modular and extensible framework, you're empowered to focus on:

🏗️ Building - Lay the foundation for something amazing.
🧪 Testing - Fine-tune your agent to perfection.
👀 Viewing - See your progress come to life.

Be part of the revolution! AutoGPT stays at the forefront of AI innovation, featuring the codebase for the reigning champion in the Open-Source ecosystem.

We're hosting a Hackathon!
Click the banner above for details and registration!

🥇 Current Best Agent: AutoGPT

Among our currently benchmarked agents, AutoGPT scores the best. This will change after the hackathon - the top-performing generalist agent will earn the esteemed position as the primary AutoGPT 🎊

📈 To enter, submit your benchmark run through the UI.

🌟 Quickstart

To build your own agent and to be eligible for the hackathon, follow the quickstart guide here. This will guide you through the process of creating your own agent and using the benchmark and user interface.
To activate the best agent follow the guide here.

Want to build your own groundbreaking agent using AutoGPT? 🛠️ There are three major components to focus on:

🏗️ the Forge

Forge your future! The forge is your innovation lab. All the boilerplate code is already handled, letting you channel all your creativity into building a revolutionary agent. It's more than a starting point, it's a launchpad for your ideas. All tutorials are located here.

📘 Learn More

🎯 the Benchmark

Test to impress! The benchmark offers a stringent testing environment. Our framework allows for autonomous, objective performance evaluations, ensuring your agents are primed for real-world action.

📘 Learn More

🎮 the UI

Take Control! The frontend is your personal command center. It gives you a user-friendly interface to control and monitor your agents, making it easier to bring your ideas to life.

📘 Learn More

🔄 Agent Protocol

🔌 Standardize to Maximize! To maintain a uniform standard and ensure seamless compatibility, AutoGPT employs the agent protocol from the AI Engineer Foundation. This standardizes the communication pathways from your agent to the frontend and benchmark.

🤔 Questions? Problems? Suggestions?

Get help - Discord 💬

To report a bug or request a feature, create a GitHub Issue. Please ensure someone else hasn’t created an issue for the same topic.

Nu1LCTF/n1ctf-2023

2023-10-26T01:22:57Z

inuad/movie-night

2023-10-25T01:24:20Z

This repository is made for hacktoberfest 2023. Share an all-time favorite movie.

morangainnocent/foyasa

2023-10-25T01:24:46Z

Foya Sa

0xDrMoe/TownofHost-Enhanced

2023-10-25T01:25:02Z

Town of Host: Enhanced

Regarding this mod

This mod is not affiliated with Among Us or Innersloth LLC, and the content contained therein is not endorsed or otherwise sponsored by Innersloth LLC. Portions of the materials contained herein are the property of Innersloth LLC.

Credit to these mods and their developers for the code and help:

⭐ TOHRE

TOH: Enhanced was forked from TOH-RE

⭐ TOHE :

TOHRE was forked from TOHE

⭐ TOH :

Our repo is based initially on TOH

⭐ TOHY :

Many role ideas

Provided roles: AntiAdminer, CursedWolf, Workaholic, Greedier (Greedy), DarkHide (Stalker)

Reference: Modify game announcement

⭐ TOH:TOR :

Many role ideas

Reference: Exile Confirm

Reference: Split RPC Pack

⭐ SNR :

Reference: Credentials menu

Reference: Switch Horse Mode

Reference: Search Mod Game

Reference: Custom Button

⭐ TOP :

Reference: Zoom

⭐ RHR :

Reference: Modify settings menu

⭐ TOH+

Provided roles: Shapeshifter, Engineer, Scientist, Marshall, Poisoner, Necroview, Sidekick

Bait and Beartrap as add-ons

⭐ Project Lotus

Ideas for some roles (such as Crusader)

⭐ TOHE+

Provided roles: Pyromaniac, Necromancer, Head Hunter (Huntsman), Alchemist, and others

⭐ TOHEX

Provided role: Swapper

⭐ Stellar Roles

Provided role: ParityCop (Inspector)

pnp/powershell

2023-10-25T01:25:02Z

PnP PowerShell

PnP PowerShell is a .NET 6 based PowerShell Module providing over 650 cmdlets that work with Microsoft 365 environments such as SharePoint Online, Microsoft Teams, Microsoft Project, Security & Compliance, Azure Active Directory, and more.

Last version	Last nightly version

This module is a successor of the PnP-PowerShell module. The original cmdlets only work on Windows and Windows PowerShell and supports SharePoint On-Premises (2013, 2016 and 2019) and SharePoint Online. This version of the cmdlets is cross-platform (i.e it works on Windows, MacOS and Linux) but it will only support SharePoint Online. Going forward we will only be actively maintaining the cross-platform PnP PowerShell module.

For more information about installing or upgrading to this module, please refer to the documentation.

IMPORTANT - New PnP PowerShell 2.x

As the technologies behind PowerShell evolve, so will the PnP PowerShell module. Microsoft is no longer supporting .NET 3.1 since December 2022, and .NET Framework is not actively being developed anymore. It is also not cross platform. PnP PowerShell 2.x will therefore no longer support PowerShell 5.1 nor the ISE.

We have created a guide for upgrading from previous versions to PnP PowerShell 2.x. If you are still using PowerShell 5.1 or the ISE, and want to use the latest major or nightly release, you will need to specify the required version like below:

Install-Module PnP.PowerShell -RequiredVersion 1.12.0 -Force

Both (1.x and 2.x) can be installed in the same machine with no conflict.

Supportability and SLA

This library is open-source and community provided library with active community providing support for it. This is not Microsoft provided module so there's no SLA or direct support for this open-source component from Microsoft. Please report any issues using the issues list.

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

hzeller/rpi-rgb-led-matrix

2023-10-25T01:26:02Z

Controlling up to three chains of 64x64, 32x32, 16x32 or similar RGB LED displays using Raspberry Pi GPIO

Controlling RGB LED display with Raspberry Pi GPIO

A library to control commonly available 64x64, 32x32 or 16x32 RGB LED panels with the Raspberry Pi. Can support PWM up to 11Bit per channel, providing true 24bpp color with CIE1931 profile.

Supports 3 chains with many panels each on a regular Pi. On a Raspberry Pi 2 or 3, you can easily chain 12 panels in that chain (so 36 panels total), but you can theoretically stretch that to up to 96-ish panels (32 chain length) and still reach around 100Hz refresh rate with full 24Bit color (theoretical - never tested this; there might likely be timing problems with the panels that will creep up then).

With fewer colors or so-called 'outdoor panels' you can control even more, faster.

The LED-matrix library is (c) Henner Zeller h.zeller@acm.org, licensed with GNU General Public License Version 2.0 (which means, if you use it in a product somewhere, you need to make the source and all your modifications available to the receiver of such product so that they have the freedom to adapt and improve).

Discourse discussion group

If you'd like help, please do not file a bug, use the discussion board instead: https://rpi-rgb-led-matrix.discourse.group/

Overview

The RGB LED matrix panels can be scored at Sparkfun, AdaFruit or eBay and Aliexpress. If you are in China, I'd try to get them directly from some manufacturer, Taobao or Alibaba.

The RGBMatrix class provided in include/led-matrix.h does what is needed to control these. You can use this as a library in your own projects or just use the demo binary provided here which provides some useful examples.

Check out utils/ directory for some ready-made tools to get started using the library, or the examples-api-use/ directory if you want to get started programming your own utils.

All Raspberry Pi versions supported

This supports the old Raspberry Pi's Version 1 with 26 pin header and also the B+ models, the Pi Zero, Raspberry Pi 2 and 3 with 40 pins, as well as the Compute Modules which have 44 GPIOs. The 26 pin models can drive one chain of RGB panels, the 40 pin models up to three chains in parallel (each chain 12 or more panels long). The Compute Module can drive up to 6 chains in parallel. The Raspberry Pi 2 and 3 are faster and generally perferred to the older models (and the Pi Zero). With the faster models, the panels sometimes can't keep up with the speed; check out this troubleshooting section what to do.

A lightweight, non-GUI, distribution such as DietPi is recommended. Raspbian Lite is a bit easier to get started with and is a good second choice.

Types of Displays

There are various types of displays that come all with the same Hub75 connector. They vary in the way the multiplexing is happening so this library supports options to choose that. All these are configured by flags (or, programmatically, in an Options struct).

If you have a 64x32 display, you need to supply the flags --led-cols=64 --led-rows=32 for instance.

Depending on the Matrix, there are various configuration options that you might need to set for it to work. See further below in the README for the detailed description of these. While the --led-rows and --led-cols can be derived from simply looking at the panels, the other options might require some experimenting to find the right setting if there is no description provided by the manufacturer of the panel. Going through these options for experiments would typically not do harm, so you're free to experiment to find your setting.

Flag	Description
`--led-cols`	Columns in the LED matrix, the 'width'.
`--led-rows`	Rows in the LED matrix, the 'height'.
`--led-multiplexing`	In particular bright outdoor panels with small multiplex ratios require this. Often an indicator: if there are fewer address lines than expected: ABC (instead of ABCD) for 32 high panels and ABCD (instead of ABCDE) for 64 high panels.
`--led-row-addr-type`	Adressing of rows; in particular panels with only AB address lines might indicate that this is needed.
`--led-panel-type`	Chipset of the panel. In particular if it doesn't light up at all, you might need to play with this option because it indicates that the panel requires a particular initialization sequence.

Panels can be chained by connecting the output of one panel to the input of the next panel. You can chain quite a few together, but the refresh rate will reduce with longer chains.

The 64x64 matrixes typically come in two kinds: with 5 address lines (A, B, C, D, E), or (A, B); the latter needs a --led-row-addr-type=1 parameter. So-called 'outdoor panels' are typically brighter and allow for faster refresh-rate for the same size, but do some multiplexing internally of which there are a few types out there; they can be chosen with the --led-multiplexing parameter.

There are some panels that have a different chip-set than the default HUB75. These require some initialization sequence. The current supported types are --led-panel-type=FM6126A and --led-panel-type=FM6127.

Generally, the higher scan-rate (e.g. 1:8), a.k.a. outdoor panels generally allow faster refresh rate, but you might need to figure out the multiplexing mapping if one of the three provided does not work.

Some 32x16 outdoor matrixes with 1:4 scan (e.g. Qiangli Q10(1/4) or X10(1/4)) have 4 address line (A, B, C, D). For such matrices is necessary to use --led-row-addr-type=2 parameter. Also the matrix Qiangli Q10(1/4) have "Z"-stripe pixel mapping and in this case, you'd use two parameters at the same time --led-row-addr-type=2 --led-multiplexing=4.

Let's do it

This documentation is split into parts that help you through the process

Wire up the matrix to your Pi. This document describes what goes where. You might also be interested in breakout boards for that. If you have an Adafruit HAT or Adafruit Bonnet, you can choose that with a command line option described below
Run a demo. You find that in the examples-api-use/ directory:

make -C examples-api-use
sudo examples-api-use/demo -D0

Use the utilities. The utils directory has some ready-made useful utilities to show content. Go there to see how to compile and run these.
Write your own programs using the Matrix in C++ or one of the bindings such as Python or C#.

Utilities

The utils directory is meant for ready utilities to show images or animated gifs or videos. Read the README there for instructions how to compile.

There are external projects that use this library and provide higher level network protocols, such as the

FlaschenTaschen implementation (VLC can send videos to it natively)
PixelPusher implementation (common in light art installations)
ZeroMQ-server to receive content.
Marc's FastLED_RPIRGBPanel_GFX allows running arduino code on linux/rPi and display on bigger RGBPanel matrices than arduino chips, can.

API

The library comes as an API that you can use for your own utilities and use-cases.

The native library is a C++ library (see include/). Example uses you find in the examples-api-use/ directory.
If you prefer to program in C, there is also a C API.
In the python subdirectory, you find a Python API including a couple of examples to get started.
There are a couple of external bindings, such as
- Nodejs binding by Maxime Journaux
- Nodejs/Typescript binding by Alex Eden
- Go binding by Máximo Cuadros
- Rust binding by Vincent Pasquier

Changing parameters via command-line flags

For the programs in this distribution and also automatically in your own programs using this library, there are a lot of parameters provided as command line flags, so that you don't have to re-compile your programs to tweak them. Some might need to be changed for your particular kind of panel.

Here is a little run-down of what these command-line flags do and when you'd like to change them.

First things first: if you have a different wiring than described in wiring, for instance if you have an Adafruit HAT/Bonnet, you can choose these here:

--led-gpio-mapping=<gpio-mapping>: Name of GPIO mapping used. Default "regular"

This can have values such as

--led-gpio-mapping=regular The standard mapping of this library, described in the wiring page.
--led-gpio-mapping=adafruit-hat The Adafruit HAT/Bonnet, that uses this library or
--led-gpio-mapping=adafruit-hat-pwm Adafruit HAT with the anti-flicker hardware mod described below.
--led-gpio-mapping=compute-module Additional 3 parallel chains can be used with the Compute Module.

Learn more about the mappings in the wiring documentation.

GPIO speed

--led-slowdown-gpio=<0..4>: Slowdown GPIO. Needed for faster Pis and/or slower panels (Default: 1).

The Raspberry Pi starting with Pi2 are putting out data too fast for almost all LED panels I have seen. In this case, you want to slow down writing to GPIO. Zero for this parameter means 'no slowdown'.

The default 1 (one) typically works fine, but often you have to even go further by setting it to 2 (two). If you have a Raspberry Pi with a slower processor (Model A, A+, B+, Zero), then a value of 0 (zero) might work and is desirable.

A Raspberry Pi 3 or Pi4 might even need higher values for the panels to be happy.

Panel Connection

The next most important flags describe the type and number of displays connected

--led-rows=<rows>        : Panel rows. Typically 8, 16, 32 or 64. (Default: 32).
--led-cols=<cols>        : Panel columns. Typically 32 or 64. (Default: 32).
--led-chain=<chained>    : Number of daisy-chained panels. (Default: 1).
--led-parallel=<parallel>: For A/B+ models or RPi2,3b: parallel chains. range=1..3 (Default: 1, 6 for Compute Module).

These are the most important ones: here you choose how many panels you have connected and how many rows are in each panel. Panels can be chained (each panel has an input and output connector, see the wiring documentation) -- the --led-chain flag tells the library how many panels are chained together. The newer Raspberry Pi's allow to connect multiple chains in parallel, the --led-parallel flag tells it how many there are.

This illustrates what each of these parameters mean:

Panel Type

Typically, panels should just work out of the box, but some panels use a different chip-set that requires some initialization. If you don't see any output on your panel, try setting:

--led-panel-type=FM6126A

Some panels have the FM6127 chip, which is also an option.

Multiplexing

If you have some 'outdoor' panels or panels with different multiplexing, the following will be useful:

--led-multiplexing=<0..17> : Mux type: 0=direct; 1=Stripe; 2=Checkered...

The outdoor panels have different multiplexing which allows them to be faster and brighter, but by default their output looks jumbled up. They require some pixel-mapping of which there are a few types you can try and hopefully one of them works for your panel; The default=0 is no mapping ('standard' panels), while 1, 2, ... are different mappings to try with. If your panel has a different mapping, you find everything you need to implement one in lib/multiplex-mappers.cc. Please send a pull request if you encounter a panel for which you needed to implement a new mapping.

Note that you have to set the --led-rows and --led-cols to the rows and columns that are physically on each chained panel so that the multiplexing option can work properly. For instance a 32x16 panel with 1:4 multiplexing would be controlled with --led-rows=16 --led-cols=32 --led-multiplexing=1 (or whatever multiplexing type your panel is, so it can also be --led-multiplexing=2 ...).

For 64x32 panels with 1:8 multiplexing, this would typically be --led-rows=32 --led-cols=64 --led-multiplexing=1; however, there are some panels that internally behave like two chained panels, so then you'd use --led-rows=32 --led-cols=32 --led-chain=2 --led-multiplexing=1;

--led-row-addr-type=<0..4>: 0 = default; 1 = AB-addressed panels; 2 = direct row select; 3 = ABC-addressed panels; 4 = ABC Shift + DE direct (Default: 0).

This option is useful for certain 64x64 or 32x16 panels. For 64x64 panels, that only have an A and B address line, you'd use --led-row-addr-type=1. This is only tested with one panel so far, so if it doesn't work for you, please send a pull request.

For 32x16 outdoor panels, that have have 4 address line (A, B, C, D), it is necessary to use --led-row-addr-type=2.

Panel Arrangement

--led-pixel-mapper  : Semicolon-separated list of pixel-mappers to arrange pixels.

Optional params after a colon e.g. "U-mapper;Rotate:90"

Available	Parameter after colon	Example
Mirror	`H` or `V` for horizontal/vertical mirror.	`Mirror:H`
Rotate	Degrees.	`Rotate:90`
U-mapper	-

Mapping the logical layout of your boards to your physical arrangement. See more in Remapping coordinates.

Misc Options

--led-brightness=<percent>: Brightness in percent (Default: 100).

Self explanatory.

--led-pwm-bits=<1..11>    : PWM bits (Default: 11).

The LEDs can only be switched on or off, so the shaded brightness perception is achieved via PWM (Pulse Width Modulation). In order to get a good 8 Bit per color resolution (24Bit RGB), the 11 bits default per color are good (why ? Because our eyes are actually perceiving brightness logarithmically, so we need a lot more physical resolution to get 24Bit sRGB).

With this flag, you can change how many bits it should use for this; lowering it means the lower bits (=more subtle color nuances) are omitted. Typically you might be mostly interested in the extremes: 1 Bit for situations that only require 8 colors (e.g. for high contrast text displays) or 11 Bit for everything else (e.g. showing images or videos). Why would you bother at all ? Lower number of bits use slightly less CPU and result in a higher refresh rate.

--led-show-refresh        : Show refresh rate.

This shows the current refresh rate of the LED panel, the time to refresh a full picture. Typically, you want this number to be pretty high, because the human eye is pretty sensitive to flicker. Depending on the settings, the refresh rate with this library are typically in the hundreds of Hertz but can drop low with very long chains. Humans have different levels of perceiving flicker - some are fine with 100Hz refresh, others need 250Hz. So if you are curious, this gives you the number (shown on the terminal).

The refresh rate depends on a lot of factors, from --led-rows and --led-chain to --led-pwm-bits, --led-pwm-lsb-nanoseconds and --led-pwm-dither-bits. If you are tweaking these parameters, showing the refresh rate can be a useful tool.

--led-limit-refresh=<Hz>  : Limit refresh rate to this frequency in Hz. Useful to keep a
                            constant refresh rate on loaded system. 0=no limit. Default: 0

This allows to limit the refresh rate to a particular frequency to approach a fixed refresh rate.

This can be used to mitigate some situations in which you have a faint flicker, which can happen due to hardware events (network access) or other situations such as other IO or heavy memory access by other processes. Also when you see wildly changing refresh frequencies with --led-show-refresh.

You trade a slightly slower refresh rate and display brightness for less visible flicker situations.

For this to calibrate, run your program for a while with --led-show-refresh and watch the line that shows the current refresh rate and minimum refresh rate observed. So wait a while until that value doesn't change anymore (e.g. a minute, so that you catch tasks that happen once a minute, such as ntp updated). Use this as a guidance what value to choose with --led-limit-refresh.

The refresh rate will now be adapted to always reach this value between frames, so faster refreshes will be slowed down, but the occasional delayed frame will fit into the time-window as well, thus reducing visible brightness fluctuations.

You can play with value a little and reduce until you find a good balance between refresh rate and flicker suppression.

Use this also if you want to have a stable baseline refresh rate when using the vsync-multiple flag -V in the led-image-viewer or video-viewer utility programs.

--led-scan-mode=<0..1>    : 0 = progressive; 1 = interlaced (Default: 0).

This switches from progressive scan and interlaced scan. The latter might look be a little nicer when you have a very low refresh rate, but typically it is more annoying because of the comb-effect (remember 80ies TV ?).

--led-pwm-lsb-nanoseconds : PWM Nanoseconds for LSB (Default: 130)

This allows to change the base time-unit for the on-time in the lowest significant bit in nanoseconds. Lower values will allow higher frame-rate, but will also negatively impact qualty in some panels (less accurate color or more ghosting).

Good values for full-color display (PWM=11) are somewhere between 100 and 300.

If you you use reduced bit color (e.g. PWM=1) and have sharp contrast applications, then higher values might be good to minimize ghosting.

How to decide ? Just leave the default if things are fine. But some panels have trouble with sharp contrasts and short pulses that results in ghosting. It is particularly apparent in situations such as bright text on black background. In these cases increase the value until you don't see this ghosting anymore.

The following example shows how this might look like:

Ghosting with low --led-pwm-lsb-nanoseconds	No ghosting after tweaking

If you tweak this value, watch the framerate (--led-show-refresh) while playing with this number.

--led-pwm-dither-bits   : Time dithering of lower bits (Default: 0)

The lower bits can be time dithered, i.e. their brightness contribution is achieved by only showing them some frames (this is possible, because the PWM is implemented as binary code modulation). This will allow higher refresh rate (or same refresh rate with increased --led-pwm-lsb-nanoseconds). The disadvantage could be slightly lower brightness, in particular for longer chains, and higher CPU use. CPU use is not of concern for Rasbperry Pi 2 or 3 (as we run on a dedicated core anyway) but proably for Raspberry Pi 1 or Pi Zero. Default: no dithering; if you have a Pi 3 and struggle with low frame-rate due to high multiplexing panels (1:16 or 1:32) or long chains, it might be worthwhile to try.

--led-no-hardware-pulse   : Don't use hardware pin-pulse generation.

This library uses a hardware subsystem that also is used by the sound. You can't use them together. If your panel does not work, this might be a good start to debug if it has something to do with the sound subsystem (see Troubleshooting section). This is really only recommended for debugging; typically you actually want the hardware pulses as it results in a much more stable picture.

--led-no-drop-privs       : Don't drop privileges from 'root' after initializing the hardware.

You need to start programs as root as it needs to access some low-level hardware at initialization time. After that, it is typically not desirable to stay in this role, so the library then drops the privileges.

This flag allows to switch off this behavior, so that you stay root. Not recommended unless you have a specific reason for it (e.g. you need root to access other hardware or you do the privilege dropping yourself).

--led-daemon              : Make the process run in the background as daemon.

If this is set, the program puts itself into the background (running as 'daemon'). You might want this if started from an init script at boot-time.

--led-inverse             : Switch if your matrix has inverse colors on.
--led-rgb-sequence        : Switch if your matrix has led colors swapped (Default: "RGB")

These are if you have a different kind of LED panel in which the logic of the color bits is reversed (--led-inverse) or where the Red, Green and Blue LEDs are mixed up (--led-rgb-sequence). You know it when you see it.

Troubleshooting

Here are some tips in case things don't work as expected.

Use minimal Raspbian distribution

In general, run a minimal configuration on your Pi.

Do not use a graphical user interface (Even though the Raspberry Pi foundation makes you believe that you can do that: don't. Using a Pi with a GUI is a frustratingly slow use of an otherwise perfectly good embedded device.). Always operate your Raspberry Pi headless.
Switch off on-board sound (dtparam=audio=off in /boot/config.txt). External USB sound adapters work, and are much better quality anyway, so that is recommended if you happen to need sound. The on-board sound uses a timing circuit that the RGB-Matrix needs (it seems in some distributions, such as arch-linux, this is not enough and you need to explicitly blacklist the snd_bcm2835 module).
Don't run anything that messes in parallel with the GPIO pins, e.g. PiGPIO library/daemon or devices that use the i2c or 1-wire interface if they are on the same pins you need for the panel.
I have also seen reports that on some Pis, the one-wire protocol is enabled (w1-gpio). This will also not work (disable by removing dtoverlay=w1-gpio in /boot/config.txt; or using raspi-config, Interface Options -> 1-Wire)
If you see some regular flickering, make sure that there is no other process running on the system that could cause that. For instance, it is known that merely running top creates a faint flicker every second it updates. Or a regular ntp run can also cause flicker once a minute (switch off with sudo timedatectl set-ntp false). Maybe instead you might want to run ntp at system start-up but then not regularly updating. There might be other things running regularly you don't need; consider a sudo systemctl stop cron for instance. To address some irregular flicker, consider the --led-limit-refresh option.
There are probably other processes that are running that you don't need and remove them; I usually remove right away stuff I really don't need e.g.
```
sudo apt-get remove bluez bluez-firmware pi-bluetooth triggerhappy pigpio
```
Take a close look at your systemd (systemctl) and see if there are other things running you don't need. If you have seen packages in standard Raspbians that interfere with the matrix code, let me know to include it here. In general: This is why starting with a minimal installation is a good idea: there is simply less cruft that you have to disable.
It seems that more recent version of Raspbian Lite result in some faint brightness fluctuations of the displays and it is not quite clear why (see issue #483). If you are a Kernel person and can help figuring out what is happening that would be very appreciated. Also, you might know a minimal Linux distribution that is more suited for near realtime applications ?

The default install of Raspbian Lite or DietPi seem to be good starting points, as they have a reasonably minimal configuration to begin with. Raspbian Lite is not as lite anymore as it used to be; I prefer DietPi these days.

Bad interaction with Sound

If sound is enabled on your Pi, this will not work together with the LED matrix, as both need the same internal hardware sub-system (a first test to see if you are affected is to run the progrem with --led-no-hardware-pulse and see if things work fine then).

If you run lsmod and see the snd_bcm2835 module, this could be causing trouble. (The library actually exits if it finds this module to be loaded).

In that case, you should create a kernel module blacklist file like the following on your system and update your initramfs:

cat <<EOF | sudo tee /etc/modprobe.d/blacklist-rgb-matrix.conf
blacklist snd_bcm2835
EOF

sudo update-initramfs -u

Reboot and confirm that the module is not loaded.

I have followed some tutorial on the Internet and it doesn't work

Well, if you use this library, please read the documentation provided here, not on some other website. Most important for you to get started is the wiring guide. There are some tutorials floating around that refer to a very old version of this library.

I have a Pi1 Revision1 and top part of Panel doesn't show green

Use --led-gpio-mapping=regular-pi1

Logic level voltage not sufficient

Some panels don't interpret the 3.3V logic level well, or the RPi output drivers have trouble driving longer cables, in particular with faster Raspberry Pis Version 2. This results in artifacts like randomly showing up pixels, color fringes, or parts of the panel showing 'static'.

If you encounter this, try these things

Make sure to have as short as possible flat-cables connecting your Raspberry Pi with the LED panel.
In particular if the chips close to the input of the LED panel read 74HC245 instead of 74HCT245 or 74AHCT245, then this board will not work properly with 3.3V inputs coming from the Pi. Use an adapter board with a bus-driver that acts as level shifter between 3.3V and 5V. (In any case, it is always a good idea to use the level shifters).
A temporary hack to make HC245 inputs work with the 3.3V levels is to supply only like 4V to the LED panel. But the colors will be off, so not really useable as long-term solution.
If you can't implement the above things, or still have problems, you can slow down the GPIO writing a bit. This will of course reduce the frame-rate, so it comes at a cost.

For GPIO slow-down, add the flag --led-slowdown-gpio=2 to the invocation of the binary.

If you have an Adafruit HAT or Bonnet

Generally, if you want to connect RGB panels via an adapter instead of hand-wiring, I suggest to build one of the adapters whose open-hardware files you find in the adapter/ subdirectory. It is a fun solder exercise with large surface mount components.

However, Adafruit offers an adapter which is already ready-made, but it only allows for a single chain. If the ready-made vs. single-chain tradeoff is worthwhile, then you might go for that (I am not affiliated with Adafruit).

Switch the Pinout

The Adafruit HAT/Bonnet uses this library but a modified pinout to support other features on the HAT. You can choose the Adafruit pinout with a command line flag.

Just pass the option --led-gpio-mapping=adafruit-hat. This works on the C++ and Python examples.

Improving flicker

To improve flicker, we need to do a little hardware modification, but it is very simple: solder a wire between GPIO 4 and 18 as shown in the following picture (click to enlarge):

Then, start your programs with --led-gpio-mapping=adafruit-hat-pwm.

Now you should have less visible flicker. This essentially switches on the hardware pulses feature for the Adafruit HAT/Bonnet.

64x64 with E-line on Adafruit HAT/Bonnet

There are LED panels that have 64x64 LEDs packed, but they need 5 address lines, which is 1:32 multiplexing (they have an E address-line). The first generation of the Adafruit HAT/Bonnet was not prepared for this, but it can be done with another hardware mod. Beginning October 2018, Adafruit began selling an updated version of the HAT that supports 64x64 panels simply by bridging two pads on the PCB with solder.

You can identify which HAT you have by looking for the Address E pads, circled here:

New Adafruit RGB Matrix Hat (with Address E pads)

Look for the Address E pads located between the HUB75 connector and Pi camera cutout.

Melt a blob of solder between the center “E” pad the the “8” pad just above it (for 64x64 matrices in the Adafruit shop)…or the “16” pad below (rare, for some third-party 64x64 matrices…check datasheet).

Old Adafruit HAT/Bonnet (without)

It is a little more advanced hack, so it is only really for people who are comfortable with this kind of thing. First, you have to figure out which is the input of the E-Line on your matrix (they seem to be either on Pin 4 or Pin 8 of the IDC connector). You need to disconnect that Pin from the ground plane (e.g. with an Exacto knife) and connect GPIO 24 to it. The following images illustrate the case for IDC Pin 4.

If the direct connection does not work, you need to send it through a free level converter of the Adafruit HAT/Bonnet. Since all unused inputs are grounded with traces under the chip, this involves lifting a leg from the HCT245 (figure out a free bus driver from the schematic). If all of the above makes sense to you, you have the Ninja level to do it!

It might be more convienent at this point to consider the Active3 adapter that has that covered already.

Running as root

The library requires to access hardware registers to control the LED matrix, and create accurate timings. These hardware accesses require to run as root user.

For security reasons, it is usually not a good idea to run an application as root entirely, so this library makes sure to drop privileges immediately after the hardware is initialized.

You can switch off the privilege dropping with the --led-no-drop-privs flag, or, if you do this programmatically, choose the configuration in the RuntimeOptions struct.

Note, you could run as non-root, which will use /dev/gpiomem to at least write to GPIO, however the precise timing hardware registers are not accessible. This will result in flicker and color degradation. Starting as non-root is not recommended.

CPU use

These displays need to be updated constantly to show an image with PWMed LEDs. This is dependent on the length of the chain: for each chain element, about 1'000'000 write operations have to happen every second! (chain_length * 32 pixel long * 16 rows * 11 bit planes * 180 Hz refresh rate).

We can't use hardware support for writing these as DMA is too slow, thus the constant CPU use on an RPi is roughly 30-40% of one core. Keep that in mind if you plan to run other things on this computer (This is less noticable on Raspberry Pi, Version 2 or 3 that has more cores).

Also, the output quality is susceptible to other heavy tasks running on that computer - there might be changes in the overall brigthness when this affects the referesh rate.

If you have a loaded system and one of the newer Pis with 4 cores, you can reserve one core just for the refresh of the display:

isolcpus=3

.. at the end of the line of /boot/cmdline.txt (needs to be in the same as the other arguments, no newline). This will use the last core only to refresh the display then, but it also means, that no other process can utilize it then. Still, I'd typically recommend it.

Performance improvements and limits

Regardless of which driving hardware you use, ultimately you can only push pixels so fast to a string of panels before you get flickering due to too low a refresh rate (less than 80-100Hz), or before you refresh the panel lines too fast and they appear too dim because each line is not displayed long enough before it is turned off.

Basic performance tips:

Use --led-show-refresh to see the refresh rate while you try parameters
use an active-3 board with led-parallel=3
led-pwm-dither-bits=1 gives you a speed boost but less brightness
led-pwm-lsb-nanoseconds=50 also gives you a speed boost but less brightness
led-pwm-bits=7 or even lower decrease color depth but increases refresh speed
AB panels and other panels with that use values of led-multiplexing bigger than 0, will also go faster, although as you tune more options given above, their advantage will decrease.
32x16 ABC panels are faster than ABCD which are faster than ABCDE, which are faster than 128x64 ABC panels (which do use 5 address lines, but over only 3 wires)
Use at least an rPi3 (rPi4 is still slightly faster but may need --led-slowdown-gpio=2)

Maximum resolutions reasonably achievable: A general rule of thumb is that running 16K pixels (128x128 or otherwise) on a single chain, is already pushing limits and you will have to make tradeoffs in visual quality. 32K pixels (like 128x256) is definitely pushing things and you'll get 100Hz or less depending on the performance options you choose. This puts the maximum reasonable resolution around 100K pixels (like 384x256) for 3 chains. You can see more examples and video capture of speed on Marc MERLIN's page 'RGB Panels, from 192x80, to 384x192, to 384x256 and maybe not much beyond' If your refresh rate is below 300Hz, expect likely black bars when taking cell phone pictures. A real camera with shutter speed lowered accordingly, will get around this.

Ultimately, you should not expect to go past 64K pixels using 3 chains without significant quality tradeoffs. If you need bigger displays, you should use multiple boards and synchronize the output.

Limitations

If you are using the Adafruit HAT/Bonnet in the default configuration, then we can't make use of the PWM hardware (which only outputs to a particular pin), so you'll see random brightness glitches. I strongly suggest to do the aforementioned hardware mod.

The system needs constant CPU to update the display. Using the DMA controller was considered but after extensive experiments ( https://github.com/hzeller/rpi-gpio-dma-demo ) dropped due to its slow speed..

There is an upper limit in how fast the GPIO pins can be controlled, which limits the frame-rate. Raspberry Pi 2's and newer are generally faster.

Even with everything in place, you might see faint brightness fluctuations in particular if there is something going on on the network or in a terminal on the Pi; this could probably be mitigated with some more real-time kernel for the Pi; maybe there are also hardware limitations (memory bus contention?). Anyway, if you have a realtime kernel configuration that you have optimized for this application, let me know.

To address the brightness fluctuations, you might experiment with the FIXED_FRAME_MICROSECONDS compile time option in lib/Makefile that has instructions how to set it up.

Fun

I am always happy to see users successfully using the software for wonderful things, like this installation by Dirk in Scharbeutz, Germany:

luigifreda/plvs

2023-10-26T01:23:48Z

PLVS is a real-time SLAM system with points, lines, volumetric mapping and 3D unsupervised incremental segmentation.

PLVS II

Author: Luigi Freda

PLVS is a real-time system that leverages sparse SLAM, volumetric mapping, and 3D unsupervised incremental segmentation. PLVS stands for Points, Lines, Volumetric mapping, and Segmentation.

PLVS is available in two different versions.

PLVS I: hosted in the branch plvs1. It is based on ORB-SLAM2, and supports mono, stereo, and RGB-D cameras.
PLVS II: hosted in the master branch. It is based on ORB-SLAM3, and also supports camera systems provided with IMUs.

Here you can find a list of the new features provided by PLVS. You can find further information and videos on this page and in the following document:

PLVS: A SLAM System with Points, Lines, Volumetric Mapping, and 3D Incremental Segmentation
Luigi Freda

Note: PLVS is an active project. This README is under construction and will be updated soon with further information and details. Code improvements are coming soon.

Quick start

The following procedures were tested under Ubuntu 20. If you don't have it, check rosdocker and use the noetic container.

Build

Install basic dependencies:
$ ./install_dependencies.sh
Install OpenCV in a local folder:
$ ./install_local_opencv.sh
(if you want, skip this step and set the variable OpenCV_DIR in config.sh with your local OpenCV path)
Build the PLVS framework:
$ ./build.sh

Under ROS noetic you can run:
$ ./build_ros_catkin.sh
to build the PLVS ROS workspace and deploy it into the ros_ws folder.

It should be easy to adapt the above procedures if you have a different OS or ROS version.

Running the examples

Once everything is built, you can enter in the Scripts folder and test the different examples. For instance you can configure and run:

$ ./run_tum_rgbd.sh for TUM RGB-D datasets
$ ./run_kitti_stereo.sh for KITTI datasets
$ ./run_euroc_stereo_inertial.sh for Euroc datasets, stereo + inertial
$ ./run_euroc_stereo.sh for Euroc datasets, only stereo
$ ./run_tum_vi_stereo.sh for TUM VI datasets, only stereo
$ ./run_tum_vi_stereo_inertial.sh for TUM VI datasets, stereo + inertial

In each of the above scripts, you have to configure the DATASET_BASE_FOLDER, the specific DATASET of interest, and the used YAML configuration file. In particular, each configuration file shows different sections with commented options. For a quick overview of the new features and their corresponding yaml options refer to new_features.md.

If you built the ROS workspace, you can use the scripts ros_xterm* to launch the PLVS ROS nodes. For instance,

with the TUM datasets, run ros_xterm_tum_rgbd.sh.

Contributing

You are welcome to contribute to the code base by using pull requests, reporting bugs, leaving comments, and proposing new features through issues. Feel free to get in touch: luigifreda(at)gmail(dot)com. Thank you!

License

We release PLVS under GPLv3 license. PLVS contains some modified libraries, each one coming with its license. Where nothing is specified, a GPLv3 license applies to the software.

Please cite our work if you use PLVS in your projects.

Credits

The PLVS I and PLVS II frameworks are based on ORB-SLAM2 and ORB-SLAM3 respectively. Many thanks to their Authors for their great work and contributions to the Research and open-source communities.

nikohoffren/fork-commit-merge

2023-10-26T01:23:48Z

Fork, Commit, Merge. A project designed to help you familiarize yourself with the open source contribution workflow on GitHub!

Welcome to "Fork, Commit, Merge"!
A project designed to help you familiarize yourself with the open source contribution workflow on GitHub, as well as to help you learn the basics of programming in different languages.

More info about this project, contributing and open source resources, are available on our website at
forkcommitmerge.io

Find awesome badges for your project in this repository: markdown-badges

Quick Start

Go to Setup Instructions and follow the instructions about how to start working with the project.
Go to Tasks and choose a task you want to work on. You can find instructions for installing the required tools for each task in Prerequisites.
Go to Submitting Your Changes and follow the instructions about how to submit your changes.

Prerequisites

Before you start, you'll need to install Git.
For HTML, HTMX, CSS, Bootstrap, JSON, YAML, TOML, XML or Markdown related issues, you don't need to install anything extra.
For SASS related issues, you need to install Node.js and NPM.
For Tailwind CSS related issues, you need to install Node.js and NPM.
For ReScript related issues, you need to install Node.js and NPM.
For CoffeeScript related issues, you need to install Node.js and NPM as well as CoffeeScript.
For JavaScript related issues, you need to install Node.js and NPM.
For TypeScript related issues, you need to install Node.js and NPM.
For React related issues, you need to install Node.js and NPM.
For Next.js related issues, you need to install Node.js and NPM.
For Three.js related issues, you need to install Node.js and NPM.
For Vue.js related issues, you need to install Node.js and NPM.
For Svelte related issues, you need to install Node.js and NPM.
For Astro related issues, you need to install Node.js and NPM.
For Angular related issues, you need to install Node.js and NPM.
For Ember.js related issues, you need to install Node.js and NPM.
For GraphQL related issues, you need to install Node.js and NPM.
For NGINX related issues, you need to install NGINX.
For Express.js related issues, you need to install Node.js and NPM.
For Electron.js related issues, you need to install Node.js and NPM.
For Jest related issues, you need to install Node.js and NPM.
For Jasmine related issues, you need to install Node.js and NPM.
For Vitest related issues, you need to install Node.js and NPM.
For C related issues, you need to install C.
For C++ related issues, you need to install C++.
For C# related issues, you need to install C# (Dotnet-SDK).
For D related issues, you need to install D (DMD Compiler).
For F# related issues, you need to install F# (Dotnet-SDK).
For Ada related issues, you need to install Ada.
For Java related issues, you need to install Java.
For Kotlin related issues, you need to install Kotlin and Java.
For Scala related issues, you need to install Scala.
For Groovy related issues, you need to install Java and Groovy.
For Python related issues, you need to install Python.
For Flask related issues, you need to install Python and Flask.
For Django related issues, you need to install Python and Django.
For Solidity related issues, you need to install Node.js and NPM as well as Installing Solidity (Truffle Ethereum Development Environment).
For Vyper related issues, you need to install Vyper.
For Ruby related issues, you need to install Ruby.
For Rails related issues, you need to install Ruby and Rails.
For Elixir related issues, you need to install Elixir.
For Crystal related issues, you need to install Crystal.
For PHP related issues, you need to install PHP.
For Laravel related issues, you need to install PHP and Laravel.
For Go related issues, you need to install Golang.
For Dart related issues, you need to install Dart.
For Flutter related issues, you need to install Dart and Flutter.
For Swift related issues, you need to install Swift.
For Julia related issues, you need to install Julia.
For Rust related issues, you need to install Rust.
For Haskell related issues, you need to install Haskell.
For Lua related issues, you need to install Lua.
For Clojure related issues, you need to install Clojure.
For OCaml related issues, you need to install OCaml.
For LaTeX related issues, you need to install LaTeX.
For Lisp related issues, you need to install Lisp.
For Fortran related issues, you need to install Fortran.
For Pascal related issues, you need to install Pascal.
For COBOL related issues, you need to install COBOL.
For Erlang related issues, you need to install Erlang.
For Smalltalk related issues, you need to install Smalltalk.
For Zig related issues, you need to install Zig.
For R related issues, you need to install R.
For Nim related issues, you need to install Nim.
For MATLAB related issues, you need to install MATLAB.
For Octave related issues, you need to install Octave.
For SQL related issues, you need to install sqlite3.
For TLA+ related issues, you need to install TLA+ Toolbox.
For Bash related issues, you need to install Bash.
For Perl related issues, you need to install Perl.
For ASM (Assembly) related issues, you need to install ASM.
For Docker related issues, you need to install Docker.

Installing an IDE

An Integrated Development Environment (IDE) is a software application that consolidates basic tools required for software testing and development. An IDE typically consists of a source code editor, build automation tools, and a debugger. Some IDEs, like Android Studio or Visual Studio, even offer more advanced features such as version control, databases, cloud services, and more. Why use an IDE? Using an IDE can significantly speed up the development process by offering a variety of tools and features under one roof.

Here are a few reasons why developers use IDEs:

Efficiency: With everything in one place, developers can write, test, and debug code without needing to switch between different tools.
Code Assistance: Many IDEs offer features like autocompletion, syntax highlighting, and suggestions, making the code-writing process smoother.
Integrated Debugging: Integrated debuggers allow developers to test and debug their programs within the IDE, speeding up the development cycle.
Extensions & Plugins: Most modern IDEs support a wide range of extensions and plugins, enabling developers to customize their environment and add even more functionalities.

We recommend using VS Code as your IDE for this project. It's free, open-source, and supports a wide range of languages and extensions. You can download it from the VS Code - Official website. However, if you prefer to use another IDE, that's fine too!

Instructions on how to install an IDE that suits for you can be found on our website at forkcommitmerge.io/ide!

Installing Git

Git is a version control system that lets you manage and keep track of your source code history.

For Linux users, you can install Git via your distribution's package manager. For example, on Arch you would use the command: sudo pacman -S git and in Ubuntu/Debian: sudo apt-get install git
For macOS users, you can install Git via Homebrew with the command: brew install git
For Windows users, download Git from Git for Windows and follow the installation instructions.

Installing Node.js and NPM

Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine, and NPM is a package manager for Node.js.

You can download Node.js and NPM from the official Node.js website. This will install both Node.js and NPM on your machine. Follow the instructions on the website to install them.

Installing SASS

For SASS related issues, you need to install Node.js and NPM.

Installing Tailwind CSS

For Tailwind CSS related issues, you need to install Node.js and NPM.

Installing ReScript

For ReScript related issues, you need to install Node.js and NPM.

Installing CoffeeScript

CoffeeScript is a programming language that transcompiles to JavaScript. It adds syntactic sugar inspired by Ruby, Python, and Haskell in an effort to enhance JavaScript's brevity and readability.

First you have to make sure you have Node.js and NPM installed.

Install CoffeeScript with this command:

npm install --global coffeescript

Installing JavaScript

For JavaScript related issues, you need to install Node.js and NPM.

Installing TypeScript

For TypeScript related issues, you need to install Node.js and NPM.

Installing React

For React related issues, you need to install Node.js and NPM.

Installing Next.js

For Next.js related issues, you need to install Node.js and NPM.

Installing Three.js

For Three.js related issues, you need to install Node.js and NPM.

Installing Vue.js

For Vue.js related issues, you need to install Node.js and NPM.

Installing Svelte

For Svelte related issues, you need to install Node.js and NPM.

Installing Astro

For Astro related issues, you need to install Node.js and NPM.

Installing Angular

For Angular related issues, you need to install Node.js and NPM.

Installing Ember.js

For Ember.js related issues, you need to install Node.js and NPM.

Installing GraphQL

For GraphQL related issues, you need to install Node.js and NPM.

Installing NGINX

For macOS:

Install Homebrew if you haven't:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Install NGINX:

brew install nginx

For Linux (Ubuntu/Debian):

Install NGINX:

sudo apt install nginx

For Windows:

Follow this guide to install NGINX on Windows.

Installing Express.js

For Express.js related issues, you need to install Node.js and NPM.

Installing Electron.js

For Electron.js related issues, you need to install Node.js and NPM.

Installing Jest

For Jest related issues, you need to install Node.js and NPM.

Installing Jasmine

For Jasmine related issues, you need to install Node.js and NPM.

Installing Vitest

For Vitest related issues, you need to install Node.js and NPM.

Installing C

Setup the C environment in VS Code:

Install the C/C++ extension for VS Code.

Set up a compiler:

Windows: Install MinGW.
macOS: Ensure you have the Xcode Command Line Tools installed (xcode-select --install).
Linux: Most distributions come with gcc installed, but if not, you can typically install it using your package manager (e.g., sudo apt install gcc for Debian-based distributions).

Installing C++

If you are using VS Code, you can install the C++ extension: Launch VS Code, head to Extensions (or press Ctrl+Shift+X), and search for C++. Install the one by Microsoft called C/C++.

Install a C++ Compiler:

Windows: Install Mingw-w64 or TDM-GCC. After installation, make sure the compiler's bin directory is in your system's PATH.
Linux: You can usually install the GCC compiler with your distribution's package manager. For example, on Ubuntu/Debian, you'd run sudo apt-get install g++.
Mac: Install Xcode from the App Store. Once Xcode is installed, you'll also have the compiler.

Installing C# (Dotnet-SDK)

Windows

Using the Installer:

Go to the .NET download page.
Under the ".NET SDK" section, choose your preferred version.
Click on the "Download x64" or "Download Arm" button for Windows.
Once downloaded, run the installer and follow the on-screen instructions.

Using the Command Line with Chocolatey:

If you have Chocolatey installed, you can use it to install the .NET SDK:

choco install dotnet-sdk

Linux

The instructions can vary depending on the Linux distribution. Here's a general overview:

Go to the .NET download page.
Under the ".NET SDK" section, choose your preferred version.
Select your specific Linux distribution from the list to get detailed instructions.

For example, for Ubuntu, the instructions at the time of writing are:

wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

sudo apt-get update
sudo apt-get install -y apt-transport-https
sudo apt-get update
sudo apt-get install -y dotnet-sdk

And for Arch Linux, you can just install the dotnet-sdk package from the official repositories:

sudo pacman -S dotnet-sdk

Please note that the version and specific commands can change, so always refer to the official documentation for the most up-to-date instructions.

macOS

Using the Installer:

Go to the .NET download page.
Under the ".NET SDK" section, choose your preferred version.
Click on the "Download .NET SDK" button for macOS.
Once downloaded, run the installer and follow the on-screen instructions.

Using Homebrew:

If you have Homebrew installed, you can use it to install the .NET SDK:

brew install --cask dotnet-sdk

After installation, you can test if it's installed correctly by running:

dotnet --version

Setting up C# in Visual Studio Code:

Launch Visual Studio Code.
Open the Extensions view (Ctrl+Shift+X).
Search for the C# extension provided by Microsoft and install it.
Once the extension is installed, it will prompt you to install the .NET Core SDK if it's not already installed. Please follow the link and instructions to install it.

Installing D (DMD Compiler)

For Windows and macOS, you can download the DMD (D Compiler) from the official website and follow the installation instructions. For Linux you can use your package manager, for example in Arch Linux you can install DMD with sudo pacman -S dmd.

VS Code Setup:

Open VS Code and go to Extensions (or press Ctrl+Shift+X).
Search for "D Programming Language (code-d)" and install it. This will add D language support in VS Code.

Installing F# (Dotnet-SDK)

For Windows Users:

F# comes bundled with Visual Studio, so installing Visual Studio with .NET support should suffice.
Alternatively, you can also install F# through the .NET SDK.

For macOS and Linux Users:

Install Mono.
Alternatively, you can also install F# through the .NET SDK.

Visual Studio Code:

Install the Ionide for F# extension for F# support in VS Code.

Installing Ada

Windows:

Download GNAT Community edition for Ada from here.
Install GNAT.
Add the GNAT bin directory to your PATH environment variable.

macOS/Linux:

Open your terminal.
Install GNAT via package manager. For example, on macOS with Homebrew: brew install gnat or on Ubuntu: sudo apt install gnat.
Confirm installation by running gnatls --version.

Installing Java

Install Java Development Kit (JDK):

Before working with Java in VS Code, you must have the Java Development Kit (JDK) installed on your machine.

Windows/Mac/Linux: You can download the JDK from Oracle's official website or opt for OpenJDK.

Install Java Extensions for VS Code:

Open VS Code, go to the Extensions view by clicking on the square icon on the sidebar or pressing Ctrl+Shift+X. Search for "Java Extension Pack" by Microsoft and install it. This pack includes essential Java extensions like Language Support, Debugging, Testing, and more.

Configure Java in VS Code:

VS Code should automatically detect the JDK you installed. If not, you can set the java.home setting in VS Code to point to your JDK location.

Installing Kotlin

macOS: brew install kotlin
Linux:
- Arch: sudo pacman -S kotlin
- Ubuntu/Debian: sudo snap install --classic kotlin
Windows: Download Kotlin Compiler and add it to the PATH.

Install Kotlin Language Extension:

For VS Code you can install the Kotlin Language Extension like this:

Go to Extensions (you can use the shortcut Ctrl+Shift+X).
Search for "Kotlin" and install the "Kotlin Language" extension by FWCD.

Install Java Development Kit (JDK):

Kotlin runs on the JVM, so you'll need the Java Development Kit - JDK installed.

Installing Scala

macOS:

brew install scala sbt

Linux:

Ubuntu/Debian:

sudo apt-get install scala sbt

Windows:

You can download and install from the official websites: Scala & SBT.

Install the Scala Language Extension for VS Code:

Open VS Code.
Navigate to Extensions (shortcut: Ctrl+Shift+X).
Search for "Scala" and install the "Scala (Metals)" extension, which is the official Scala language server.

Installing Groovy

Install Java:

Groovy runs on the JVM, so you'll need Java installed.

Install Groovy:

On Windows: You can use the Groovy Windows Installer to install Groovy easily.
On macOS: You can use Homebrew to install Groovy. Open your terminal and run brew install groovy.
On Linux: You can use a your distribution's package manager to install Groovy. For example, on Ubuntu/Debian, you can run sudo apt-get install groovy and on Arch Linux sudo pacman -S groovy.

Installing Python

Windows:

Visit the official Python website's download page.
Click on the latest Python release.
Scroll down to the Files section and download the Windows x86-64 executable installer for 64-bit version of Windows.
Run the installer file and follow the instructions, making sure to tick the box that says "Add Python to PATH" before clicking Install Now.

Mac OS:

Mac OS X should come pre-installed with Python, but in case it's not installed, here's how to install it:

Visit the official Python website's download page.
Click on the latest Python release.
Download the macOS 64-bit installer.
Open the downloaded .pkg file and follow the instructions to install Python.

Linux:

Most Linux distributions come with Python pre-installed. To check if you have Python installed, open a terminal and type python3 --version.

If you need to install or upgrade Python, you can do so with the package manager for your Linux distribution. For Ubuntu, you can use the following commands:

sudo apt update
sudo apt install python3

Installing Flask

You should have already installed Python before installing Flask. If you haven't, please do so first. You can check if you have Python installed by opening a terminal and typing python3 --version. In most operating systems, after you have Python installed, you can install Flask with the command:

pip install Flask

In Arch Linux you can run:

sudo pacman -S python-flask

Installing Django

Install Python if you haven't already.
Install Django:
- With pip: pip install django
- In Arch Linux you can use: sudo pacman -S python-django

Installing Solidity (Truffle Ethereum Development Environment)

Before you can start writing Solidity code, you need to install Node.js and NPM. After installing Node.js and NPM, you can install the Truffle development environment for Ethereum with this command:

npm install -g truffle

If you are using VS Code, you can install the "Solidity" extension by Juan Blanco from the VS Code Marketplace.

Installing Vyper

It is highly recommended to use a Python virtual environment. If you don't have virtualenv installed, you can install it using pip:

pip install virtualenv

Create a new virtual environment:

virtualenv vyper-env

Activate the virtual environment:

On macOS and Linux:

source vyper-env/bin/activate

On Windows:

.\vyper-env\Scripts\activate

Install Vyper within the virtual environment:

pip install vyper

Installing Ruby

Windows:

Download the RubyInstaller for Windows from the official website. Run the installer package and follow the on-screen instructions.

Mac OS:

Ruby comes pre-installed on Mac OS X, but if you need to upgrade or install a different version, you can use Homebrew or RVM (Ruby Version Manager).

With Homebrew:

Open terminal and type brew install ruby

With RVM:

Open Terminal and type \curl -sSL https://get.rvm.io | bash -s stable Then install Ruby with rvm install ruby

Linux:

Ubuntu/Debian:

Open Terminal and type sudo apt-get install ruby-full

Arch Linux:

Open Terminal and type sudo pacman -S ruby

For other Linux distributions, the command may be different. Refer to the documentation specific to your package manager.

Installing Rails

Install Ruby if you haven't already.

MacOS:

Install Homebrew if you haven't already: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
Install Ruby: brew install ruby
Install Rails: gem install rails

On Windows:

Download RubyInstaller from here.
Follow the installation steps.
Open command prompt and run gem install rails.

On Linux:

Install RVM (Ruby Version Manager): \curl -sSL https://get.rvm.io | bash -s stable --ruby
Install Ruby: rvm install ruby
Install Rails: gem install rails

Installing Elixir

Install the ElixirLS extension for VS Code: Launch VS Code, head to Extensions (or press Ctrl+Shift+X), and search for ElixirLS. This extension provides Elixir language support and debugger.

Install Elixir:

Windows: The easiest way to install Elixir on Windows is by using Windows Subsystem for Linux (WSL).
Linux: You can typically install Elixir through your distribution's package manager. For example, on Ubuntu/Debian:

sudo apt-get install elixir

Mac: You can use Homebrew:

brew install elixir

Installing Crystal

Linux (Ubuntu): sudo apt install crystal Linux (Arch): sudo pacman -S crystal macOS: brew install crystal Windows: Official Installation Guide

VS Code Extension:

Install the Crystal Language extension by The Crystal Programming Language for syntax highlighting, code completion, and more.

Installing PHP

Windows:

Download the PHP ZIP package from https://windows.php.net/download.
Extract the ZIP file and rename the extracted directory to php.
Move the php directory to C:.
Add C:\php to your system's PATH environment variable.

Mac OS:

PHP comes pre-installed on Mac OS X. To upgrade or install a different version, consider using Homebrew:

Open Terminal and type brew install php.

Linux (Ubuntu/Debian):

Open Terminal and type sudo apt install php.

Installing Laravel

Install PHP:

If you haven't already, you need to install PHP first to work with Laravel.

Install Laravel:

Make sure you have Composer installed. If not, download and install it from the Official Composer website.
After installing Composer, open your terminal and run composer global require laravel/installer to install Laravel.
You might need to add the composer's bin directory to your PATH environment variable. For example, on Windows, you would add C:\Users\<username>\AppData\Roaming\Composer\vendor\bin to your PATH and in Linux export PATH=$PATH:~/.config/composer/vendor/bin to your .bashrc file.

Installing Golang

For macOS and Linux, you can use the terminal to install Go:

On macOS, if you have Homebrew installed, type: brew install go.
On Linux, the command will depend on your distro's package manager. For example, on Ubuntu or Debian, you would type: sudo apt-get install golang.
On Windows, go to the official Go downloads page, and download the binary release suitable. Use the MSI installer and follow the prompts to install the Go tools. It is recommended to leave the default settings for when asked about installation directory or PATH variables.

To check your installation, open a terminal and type: go version. This should return the installed version of Go.

Installing Dart

For macOS and Linux, you can use the terminal to install Dart:

On macOS, if you have Homebrew installed, type: brew install dart.
On Linux, the command will depend on your distro's package manager. For example, on Ubuntu or Debian, you would type: sudo apt-get install dart.

For Windows, go to the official Dart SDK Install page, and download the SDK suitable for your system. Use the Dart installer and follow the prompts to install the Dart SDK. It is recommended to leave the default settings for when asked about installation directory or PATH variables.

To check your installation, open a terminal and type: dart --version. This should return the installed version of Dart.

Installing Flutter

Flutter installation includes several steps, so it's recommended to follow the official Flutter installation guide.

Installing Flutter requires also installing Dart, which you can either install separately here, but it can also be installed with Android Studio or XCode. You can use VS Code as your IDE if you like, but it is recommended to still install Android Studio for Windows and Linux or Xcode for MacOS, as they include the Android SDK and iOS SDK respectively. However, you can also install Flutter without installing Android Studio or Xcode, but you'll need to install the Android SDK and iOS SDK separately.

Install Flutter and Dart Plugins in VS Code:

Open VS Code and go to Extensions (Ctrl+Shift+X).
Search for "Flutter" and install it.
The Dart plugin will be automatically installed along with Flutter.

Installing Swift

Install Swift:

For macOS: Swift comes pre-installed. If not, you can download it from the Swift website.
For Linux: Follow the instructions on the Swift website for Linux installations.

VS Code Setup:

Search for the "Swift" extension by Swift Server Work Group and install it. This extension provides support for Swift language, including features like autocomplete, linting, and debugging.

Additional Resources:

Swift.org - Getting Started

Installing Julia

Windows: Download the installer from the Official Julia website and follow the instructions.
macOS: Download the macOS installer from the Official Julia website and follow the instructions.
Linux: Use the appropriate package manager for your distribution. For example in Arch Linux you would use sudo pacman -S julia, or download the binaries from the Official Julia website.

Install the Julia extension for VS Code:

Go to the Extensions view by clicking on the Extensions icon in the Activity Bar on the side of the window.
Search for "Julia" and install the extension provided by the Julia Language team.

Installing Rust

Windows:

Go to rust-lang.org to download the "rustup-init.exe" installer.
Run the installer and follow the on-screen instructions.
Once installation is complete, open a new Command Prompt and verify with rustc --version.

Mac and Linux:

Open a terminal.
Run the following command:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Follow the on-screen instructions.
Restart your terminal (or source the changes as instructed at the end of the installation) to ensure the cargo and rustc commands are available.
You can verify the installation with rustc --version.

Installing Haskell

Install Haskell Platform:

The Haskell Platform provides everything needed to get started with Haskell.

Windows: You can download the Haskell Platform from Haskell's official website.
Mac/Linux: You can install GHCup for Haskell by running curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh in your Terminal and following the instructions.

Install Haskell Extensions for VS Code:

Open VS Code, go to the Extensions view by clicking on the square icon on the sidebar or pressing Ctrl+Shift+X. Search for "Haskell Syntax Highlighting" and install it. Also, consider installing "Haskell Language Server" for enhanced features such as type information, autocompletion, and more.

Installing Lua

macOS: brew install lua
Ubuntu/Debian: sudo apt-get install lua5.3
Arch Linux: sudo pacman -S lua
Windows: Download and install from the official website: Lua.org

Installing Clojure

On macOS:

brew install clojure/tools/clojure

On Linux (using curl):

curl -O https://download.clojure.org/install/linux-install-1.10.3.967.sh
chmod +x linux-install-1.10.3.967.sh
sudo ./linux-install-1.10.3.967.sh

On Arch Linux:

sudo pacman -S clojure

On Windows:

Download the Windows installer from the Clojure Official Site.

Setting up Calva for VS Code:

Install the Calva extension from the VS Code marketplace. Calva is a rich integrated development environment for Clojure, providing an interactive REPL, linting, and more.

Install Leiningen, a popular Clojure build tool:

On macOS:

brew install leiningen

On Arch Linux:

sudo pacman -S leiningen

Installing OCaml

You can use the OPAM (OCaml Package Manager) to install the OCaml compiler and tools.

On macOS:

brew install opam
opam init
opam switch create 4.13.1
eval $(opam env)

On Linux (Ubuntu/Debian):

sudo apt-get install opam
opam init
opam switch create 4.13.1
eval $(opam env)

On Windows:

Installation is a bit more involved. Consider using WSL (Windows Subsystem for Linux) or refer to the official OCaml for Windows instructions.

Installing LaTeX

Depending on your operating system, you'll need a TeX distribution:

Windows: MikTeX or TeX Live
macOS: MacTeX
Linux: TeX Live (sudo apt-get install texlive for Debian/Ubuntu distributions)

While you can use any text editor (like VS Code) to write LaTeX, specialized LaTeX editors make the process smoother. You can download for example TeXstudio, TeXmaker, or Overleaf.

Installing Lisp

Install SBCL (Steel Bank Common Lisp):

Depending on your OS, you can follow the instructions on the Official SBCL website to install SBCL.

Install the Lisp Extension for VS Code:

Open Visual Studio Code.
Go to Extensions.
Search for Lisp and install any Lisp extension you like. Usually the one that has the most downloads is the most safest.

Set Up Your Lisp Environment (Windows):

After installing the extension, you may need to set up your Lisp environment by pointing it to your SBCL installation. You need to adjust the configuration (settings.json) and set the lisp.sbcl.path to the path where SBCL is installed.

Installing Fortran

Installing Fortran Compiler:

Depending on your OS, here's how you install the Fortran compiler:

Windows:

Download and install the MinGW-w64 compiler which includes Fortran.
Add the bin directory of your MinGW-w64 installation to your PATH environment variable.

Linux:

Ubuntu/Debian:

sudo apt-get install gfortran

Arch Linux:

sudo pacman -S gcc-fortran

macOS:

If you have Homebrew:

brew install gcc

Setting up Visual Studio Code:

Install Visual Studio Code.
Open VS Code and go to the Extensions view by clicking on the square icon on the sidebar or pressing Ctrl+Shift+X.
Search for and install the "Modern Fortran" extension for Fortran support.
For better integration, you can also install the "Code Runner" extension which will allow you to run your Fortran code directly from VS Code.

Installing Pascal

Windows:

Download and install the Free Pascal compiler from here.
Install the Pascal extension from the Visual Studio Code marketplace.
Configure the path for the Free Pascal compiler in your settings if needed.

Linux:

Install the Free Pascal compiler using your package manager, e.g., sudo apt install fp-compiler on Ubuntu.
Install the Pascal extension from the Visual Studio Code marketplace.
Configure the path for the Free Pascal compiler in your settings if needed.

macOS:

Install Free Pascal via Homebrew with brew install fpc.
Install the Pascal extension from the Visual Studio Code marketplace.
Configure the path for the Free Pascal compiler in your settings if needed.

Installing COBOL

Installing GnuCOBOL:

For Windows: Download from SourceForge.
For Linux: Use the package manager, like sudo apt install gnucobol or equivalent for your distribution.
For macOS: Use Homebrew with brew install gnu-cobol.

Installing Erlang

Windows:

Download the installer from the official Erlang website: Erlang Downloads
Run the installer and follow the on-screen instructions.

Linux: Ubuntu/Debian:

sudo apt-get install erlang

Arch Linux:

sudo pacman -S erlang

macOS:

Using Homebrew:

brew install erlang

Setting up VS Code extension:

Search for erlang and install the Erlang extension provided by "Pierrick Gourlain".

Installing Smalltalk

If you're using Linux, you can install GNU Smalltalk through your package manager. For example, on Ubuntu:

sudo apt-get install gnu-smalltalk

In Arch Linux you can download Smalltalk packages from AUR repositories. For example, you can use Yay:

yay -S smalltalk

For other OS installations, you can visit GNU Smalltalk official website.

Installing Zig

Windows and macOS:

Download the Zig compiler from the official Zig website: Zig Downloads
Extract the downloaded package to a directory of your choice.
Add the bin directory inside the extracted folder to your system's PATH.

Linux:

The command depends on your distribution.

For example, on Ubuntu/Debian, you can use:

sudo apt-get install zig

In Arch Linux:

sudo pacman -S zig

Setting up VS Code extension:

Open the Extensions view (Ctrl+Shift+X).
Search for zig and install the Zig Language extension provided by "ziglang".

Installing R

Windows:

Download R from CRAN and install it.
Download Rtools and install it.
Add R and Rtools to your system PATH.

macOS:

You can install R using Homebrew: brew install R.

Linux:

Use your package manager to install R. For example, on Ubuntu: sudo apt-get install r-base and on Arch: sudo pacman -S r.

Setting up VS Code extension:

Open the Extensions view (Ctrl+Shift+X).
Search for R and install the R extension provided by "REditorSupport".

Installing Nim

On Windows:

Download the Nim installer from the Official Nim website and follow the installation instructions.

On macOS:

You can use Homebrew to install Nim. Open your terminal and run brew install nim.

On Linux:

You can use a package manager like apt, dnf, or pacman to install Nim. For example, on Ubuntu/Debian-based systems, run sudo apt-get install nim or on Arch Linux sudo pacman -S nim.

Installing MATLAB

Install MATLAB:

Ensure you have MATLAB installed on your computer. You can download and install MATLAB from the official MathWorks website: Download MATLAB

Install the MATLAB Extension for Visual Studio Code:

Open Visual Studio Code and go to the Extensions view by clicking on the square icon in the sidebar on the left or using the shortcut Ctrl+Shift+X (Windows/Linux) or Cmd+Shift+X (macOS).
Search for "MATLAB" in the Extensions view search bar. You should find an extension named "MATLAB" by MathWorks. Click the Install button to install it.

Configure the MATLAB Extension:

Once the extension is installed, configure it to work with your MATLAB installation. You may need to specify the MATLAB executable path in the VS Code settings.

Installing Octave

Install Octave:

Download and install Octave for your operating system from the official Octave website.

Install the Octave extension for VS Code:

Open VS Code, go to the Extensions view by clicking on the square icon in the sidebar or pressing Ctrl+Shift+X, and search for "Octave". Install the "Octave" extension provided by Juan Manuel Franco C.

Installing sqlite3

macOS and Linux:

SQLite comes pre-installed on macOS and most Linux distributions. To verify if sqlite3 is installed, you can open a terminal and type:

sqlite3 --version

If SQLite is installed, this will output the version number.

Windows:

To install SQLite on Windows:

Visit the SQLite download page.
In the "Precompiled Binaries for Windows" section, download the sqlite-tools-win32-x86-xxxxxx.zip file.
Unzip the downloaded file. It will create a directory named sqlite-tools-win32-x86-xxxxxx.
Move the directory to C:\ (or another location if you prefer) and rename it to sqlite.
Add C:\sqlite to your PATH environment variable.

To check whether SQLite has been installed successfully, open Terminal window and run:

sqlite3 --version

This should output the version number if SQLite is installed correctly.

Note that the terminal in Visual Studio Code (VS Code) uses your system's PATH, so once you've added SQLite to your PATH as described above, you'll be able to use SQLite in the VS Code terminal.

Installing TLA+ Toolbox

The TLA Toolbox is an IDE (integrated development environment) for the TLA+ tools.

Install the TLA+ Toolbox: This is the standard IDE for TLA+. You can download it from here.

Install the TLA+ extension for Visual Studio Code from the VS Code marketplace.

Installing Bash

Ensure you have a UNIX-like environment. If you're on Linux or MacOS, you're already set. Windows users might want to look into WSL (Windows Subsystem for Linux) or use Git Bash, which you should already have in your machine if you have installed Git.

Installing Perl

Windows: Use Strawberry Perl. Download the installer and follow the on-screen instructions.
macOS: Perl comes pre-installed. You can check its version by typing perl -v in your terminal.
Linux: Depending on your distribution, you can use your package manager. For example, on Debian-based systems, you can use sudo apt-get install perl and in Arch Linux sudo pacman -S perl.

Setting up VS Code for Perl:

Search for the extension "Perl" in VS Code's extensions marketplace and install it for syntax highlighting and basic debugging support.

Installing ASM (Assembly)

Windows

Using NASM with Cygwin:

Download the Cygwin installer from Cygwin's website.
Run the installer and select the packages "nasm" and "gcc-core" for installation.
Complete the installation process.

Now you can use the Cygwin terminal to assemble and run your Assembly programs.

Linux (Ubuntu/Debian)

Open the terminal and run the following command to install GNU Assembler (GAS):

sudo apt update
sudo apt install build-essential

To install NASM, run:

sudo apt install nasm

macOS

Install NASM using Homebrew:

brew install nasm

Installing Docker

Windows

Docker Desktop for Windows: You must have Hyper-V and Containers Windows features enabled.
- Download the installer from Docker Hub.
- Run the installer and follow the instructions.
- After installation, the Docker daemon should start automatically. You can manage it through the system tray.
Docker Toolbox: For older systems that do not meet the Docker Desktop for Windows requirements.
- Download the installer from Docker Toolbox GitHub releases.
- Run the installer and follow the instructions.

macOS

Docker Desktop for Mac:
- Download the installer from Docker Hub.
- Drag and drop the Docker app into the Applications folder.
- Run the Docker app. Docker will prompt you for permissions to install its components. Allow it.

Linux (Ubuntu/Debian)

Update package index and install prerequisites:

sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

Add Docker’s official GPG key:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Add Docker APT repository:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Update package index and install Docker:

sudo apt-get update
sudo apt-get install docker-ce

Start and enable Docker service:

sudo systemctl enable docker
sudo systemctl start docker

After installation on any of these platforms, you can verify the installation by running docker --version in a terminal to see the installed Docker version.

Remember to consult the official documentation for the most up-to-date and detailed instructions:

Docker for Windows installation guide
Docker for Mac installation guide
Docker for Linux (Ubuntu/Debian) installation guide

Installing Mojo

macOS

Install Brew by following this guide.
Open a terminal and run the following commands:

brew update
brew upgrade modular
modular install mojo

Linux (Ubuntu/Debian)

To install Mojo on Linux (Ubuntu/Debian), you need to install Modular first. Follow these steps:

sudo apt update
sudo apt install modular
modular install mojo

Setup Instructions

Fork this repository by clicking on the "Fork" button at the top-right corner of this page. This creates a copy of the repository in your GitHub account.

Clone your forked repository by clicking the "Code" button:

That will open this small window:

After that you can copy and paste the URL the to your local machine with the command:

git clone https://github.com/<your-username>/fork-commit-merge.git

Replace 'your-username' with your GitHub username.

Navigate to your project folder:

cd fork-commit-merge

Add a reference to the original repository for future updates:

git remote add upstream https://github.com/nikohoffren/fork-commit-merge.git

(Remember to keep here the original repository URL, not your forked one, so the username in this needs to be nikohoffren.)

Check the remotes for this repository:

git remote -v

You should now see the origin and upstream remotes listed.

Take a pull from the upstream repository to your main branch to keep it at par with the main project:

git pull upstream main

Create a new branch with the command:

git switch -c fix-issue

Now you are ready to start working on the issues! Remember every once in a while to pull from the upstream repository to keep your local repository up to date with the main project.

If you are not familiar about the contribution process, you can check out some useful videos in our website's Resources section: forkcommitmerge.io/resources.

Note: We recommend to always create new branch with each Issue you solve! Otherwise the pull requests will get too large and there could be possible merge conflicts.

Tasks

Note: These tasks will not count towards Hacktoberfest, since this repository is an educational repository, hence against the hacktoberfest guidelines.

We present over 110 several tasks for different languages, libraries and frameworks with varying difficulty. You can choose which task you want to work with and which difficulty you want to solve. You can also choose to solve multiple tasks if you want to. Just remember to create a new branch for each task you solve.

Firstly, open the tasks directory and select which language you want to work with by opening one of the following directories:

HTML
HTMX
CSS
SASS
Tailwind CSS
Bootstrap CSS
ReScript
CoffeeScript
JavaScript
JavaScript/Jest
JavaScript/Jasmine
TypeScript
TypeScript/Vitest
React
Next.js
Three.js
Vue.js
Svelte
Astro
Angular
Ember.js
GraphQL
NGINX
Express.js
Electron.js
C
C++
C#
D
F#
Ada
Java
Kotlin
Scala
Groovy
Python
Flask
Django
Solidity
Vyper
Ruby
Rails
Elixir
Crystal
PHP
Laravel
Go
Dart
Flutter
Swift
Julia
Rust
Haskell
Lua
Clojure
OCaml
LaTeX
Lisp
Fortran
Pascal
COBOL
Erlang
Smalltalk
Zig
R
Nim
MATLAB
Octave
SQL
TLA+
Bash
Perl
ASM (Assembly)
JSON
YAML
TOML
XML
Markdown
Docker

Then you can open one of these directories to choose between three difficulties:

Easy
Medium
Hard

After that you are ready to get solving!

Go to the task you selected to get more info about the issue by clicking one of the following:

HTML - Easy

HTML - Medium

HTML - Hard

HTML/CSS/JavaScript - Hard

Tailwind CSS - Medium

Bootstrap CSS - Easy

Bootstrap CSS - Medium

ReScript - Easy

CoffeeScript - Easy

CoffeeScript - Medium

JavaScript - Easy

JavaScript - Medium

JavaScript/Jest - Medium

JavaScript/Jest - Hard

JavaScript/Jasmine - Easy

TypeScript - Easy

TypeScript - Medium

TypeScript - Hard

TypeScript/Vitest - Easy

ASM (Assembly) - Easy

Note: You don't have to ask a permission to start solving the issue or get assigned, since these issues are supposed to always be open for new contributors. You can just simply start working with the issue right away! Remember that in real world issues you would usually need to ask permission to get assigned to certain issue to prevent multiple people to working on the same issue at the same time, which would result some contributors wasting their time.

Submitting Your Changes

Once you've made the necessary changes requested in the task, you're ready to submit your changes!

Stage your changes with the command:

git add files-that-you-changed

Commit your changes with the command:

git commit -m "Fixed issue"

Push your changes to your forked repository with the command:

git push origin fix-issue

Once you've pushed your changes to GitHub, you're ready to create a pull request. Go to your forked repository on GitHub.

You should see text "fix-issue had recent pushes" (or whatever your branch name is) and button "Compare & pull request" next to it.

Click the "Compare & pull request" button to proceed to the pull request page of the original fork-commit-merge repository.
Fill in the title and description boxes to inform what you did in the task and how you got it to work. You can also add some additional information such as screenshots, if you want or if they are required in the task description.
Finally, click "Create pull request" to finish creating the pull request.

Congratulations on making your first open source contribution on GitHub!

Sit back and wait for a response and feedback of the pull request. If everything is working fine, you should get the pull request merged. If not, you will be requested to do some changes to your code.

Remember to wait for us to review your pull request, do not close it yourself. If you are asked to make changes, you can do so by committing them to the same branch, there is no need to close the current Pull Request and open a new one.

After the merge, actions-user bot will reset the files for the next contributor.

All the contributors of this project will also be added to the List of Contributors in our website. In the website you can also find more information about the project, as well as your own contribution history for this project, if you login with your Github account.

Best Practices

Programming languages, despite their diverse syntax and underlying paradigms, universally emphasize the importance of adhering to best practices. These practices evolve over time, influenced by shared challenges faced by developers, innovations in the field, and the inherent features and limitations of the languages themselves. This section serves as a compass, guiding you through the idiomatic ways of coding in various languages, ensuring not only that your code works but also that it aligns with the conventions and norms of the community.

Why Follow Best Practices?

Readability: Code is read more often than it's written. Adopting best practices ensures your code remains accessible and comprehensible to other developers, or even to your future self!
Maintainability: Idiomatic code, by adhering to established patterns and standards, is easier to update, debug, and expand upon.
Performance: Often, best practices evolve in response to the understanding of a language's performance characteristics. Writing idiomatic code might also mean squeezing the best performance out of your programs.
Community Support: If you're writing code in the way that the broader community expects, you're more likely to receive help when you run into issues. Moreover, you can benefit from tools, linters, and extensions built with these practices in mind.
Reducing Errors: Many best practices are born from the lessons of countless debugged issues. By adhering to them, you’re sidestepping many pitfalls before they even occur.

In our Fork, Commit, Merge website, you'll find guides tailored to various languages, libraries and frameworks. Whether you're dabbling in a new language or revisiting a familiar one, these insights will help ensure your code is elegant, efficient, and effective.

Influences

This project was inspired by a number of fantastic resources designed to help newcomers make their first contributions to open source. In particular, we would like to acknowledge:

First Contributions: A hands-on guide to making your first open source contribution.
Contribute To This Project: A project that encourages contributors to add their own profile information.
Contribute to Open Source: A project that simulates the GitHub workflow to help beginners get their first taste of open source.

I highly recommend checking out these projects if you want to learn more about contributing to open source!

What's Next?

Congratulations on making your first open source contribution! If you're looking for more ways to contribute, you are also welcome to work with the Fork, Commit, Merge website repo, which is located here. The website is built with React, NextJS, TypeScript, TailwindCSS, MongoDB Atlas and Github OAuth/API. So if you are interested of those technologies, you can contribute to the website repo by creating new features, fixing bugs or improving the code quality.

You can also check out more information about how to make open source contributions in How to Contribute of our website.

Also i would really appreciate if you could leave a star, so more developers can find this project. I look forward to seeing your contributions!

Leaderboard

You can find the leaderboard of the Top 20 contributors in our website at forkcommitmerge.io/leaderboard. You can also find your own contribution history for this project in the website, if you login with your Github account.

Creating New Tasks

Feel free to contribute to this project also by creating new tasks for other contributors to tackle. To do so, please submit a pull request containing detailed information about the task, such as level of difficulty, language/library/framework or other technology, and relevant code examples. We encourage you to propose tasks across all different programming languages, libraries, frameworks and other technologies in the world.

Contact

For any queries, feel free to open an issue or reach out to me at niko.hoffren@gmail.com.

License

This project is licensed under the terms of the MIT License.

List of Contributors

Massive thanks to all of the these fine individuals who contributed to this project!

kleiton0x00/Proxy-DLL-Loads

2023-10-26T01:23:37Z

A proof of concept demonstrating the DLL-load proxying using undocumented Syscalls.

Proxy DLL Loads

A proof of concept demonstrating the DLL-load proxying using undocumented Syscalls. This repo is not about teaching you what DLL Load proxying is and how it works, it is greatly explained on this blogpost. Instead, the main focus is on finding undocumented callback functions by reversing the DLLs and creating your own version.

Hunting for undocumented syscalls

Before getting in directly to reversing the DLLs, we need to first know what to look for. We can start by looking at the Microsoft documentation (MSDN), which provides an excellent example of a custom thread pool, which creates a work item and a thread pool timer. The code alone is also suitable for archiving the execution of LoadLibrary via callback functions, but as already known, the userland functions are prone to hooking. So using their respective syscalls would be a better approach. Looking at the MSDN documentation, the example code uses the following Win32API functions:

CreateThreadpool
SetThreadpoolThreadMaximum
SetThreadpoolThreadMinimum
CreateThreadpoolCleanupGroup
CreateThreadpoolTimer
SetThreadpoolTimer
CloseThreadpoolCleanupGroupMembers

If you use IDA, open kernel32.dll, go to "Exports" and search for the mentioned Win32 APIs, in this case CreateThreadpool. Double-clicking the function redirect us to its dissassembled code:

Through the assembly instructions, we see the TpAllocPool syscall being executed: call cs:__imp_TpAllocPool

If you repeat the process with the other functions, you will end up with the following syscalls:

Ntdll!TpAllocPool
Ntdll!TpSetPoolMaxThreads
Ntdll!TpSetPoolMinThreads
Ntdll!TpAllocCleanupGroup
Ntdll!TpAllocTimer
Ntdll!TpSetTimer
Ntdll!TpReleaseCleanupGroupMembers

Now you have everything you need to start creating your own version of proxying the DLL Loads. You can look at this documentation from Process Hacker to help you implement the undocumented syscalls in your code.

Debugging

Set a breakpoint before the assembly code in Callbackstub get's executed. Look at right tab of x64dbg as the registers are being populated.

https://github.com/kleiton0x00/Proxy-DLL-Loads/assets/37262788/73af5145-2b1c-486b-ae9f-583c4e865df6

RAX -> pointer to LoadLibraryA
RCX -> library name string

Result

Resources

https://0xdarkvortex.dev/proxying-dll-loads-for-hiding-etwti-stack-tracing/
https://github.com/hlldz/misc/tree/main/proxy_calls
https://processhacker.sourceforge.io/doc/nttp_8h.html#adad18de6710381f08cf36a0fa72e7529

Detections

https://github.com/elastic/protections-artifacts/blob/main/behavior/rules/defense_evasion_library_loaded_via_a_callback_function.toml

stas00/the-art-of-debugging

2023-10-26T01:23:37Z

The Art of Debugging

This guide will teach you how to:

Debug normal issues really fast
Make complicated issues possible to debug

footnote: adapted from Perl's slogan: "Easy things should be easy and hard things should be possible".

This is a work-in-progress collection of methodologies and copy-n-paste recipes for successful debugging of simple and complicated software problems. Some sections are quite complete, while other will be finished at a later stage, and yet other haven't been started.

Intro

I have been developing software since 1995 and a lot of this work involved debugging. Over the years I developed a various efficient methodologies for discovering the source of the problem, which is the most difficult stage to solving it. Since after the problem is understood, typically the resolution is relatively easy.

Every so often someone I would be debugging a problem with would suggest to share my approaches with the world. I always said that it'd be too difficult to generalize, but recently the planted seed seems to have sprouted and so in the following documents I will try to share some of the insights to ease this very difficult at times process.

Writing about debugging in the void is very difficult and since I haven't been saving use cases, it will take some time to build this up, so expect these pages to be a Work In Progress (WIP) for many moons. But hopefully some ideas could be relayed to you sooner than later, and they would help to ease your burden of debugging in your work and play projects.

Fast Debugging Methodology

Debugging Compiled Programs - gdb, ldd, nm, LD_LIBRARY_PATH, LD_PRELOAD

Debugging Python - py-spy, paths, auto-print

Unix Tools For Debugging - bash, strace, make

Debugging Machine Learning Projects (external)

Contributing

If you found a bug, typo or would like to propose an improvement please don't hesitate to open an Issue or contribute a PR.

Requests

If you're struggling with a particular use-case not yet covered here, please open an Issue where you explain in details the situation, how it can be reproduced and hopefully I can help you find a working approach or at least make some suggestions that may help unblocking you.

Unless this is urgent please hold on on those requests for a bit while I write out the bulk of the know-how as chances are it'll be already covered here.

License

The content of this site is distributed under Attribution-ShareAlike 4.0 International.

My repositories map

✔ Machine Learning: ML Engineering | ML ways | Porting

✔ Guides: The Art of Debugging

✔ Applications: ipyexperiments

0Nera/BMOSP

2023-10-26T01:23:37Z

БМПОС - Базовая Модульная Платформа Операционных Систем для платформы x86_64

БМПОС: Базовая Модульная Платформа Операционных Систем

БМПОС - Базовая Модульная Платформа Операционных Систем для платформы x86_64 (BIOS/UEFI). Это отечественное программное обеспечение, созданное при поддержке Синапс ОС на языке программирования C.

БМПОС не является операционной системой. Это платформа для изучения.

Философия БМПОС - "всё есть модуль".

Реализовано

Ядро:

Менеджер памяти
Менеджер видеопамяти
Менеджер потоков
Загрузчик модулей
Буфферы ввода-вывода

Модули:

Оболочка ввода-вывода

Драйвера:

PS/2 (Клавиатура)
SATA (AHCI) (Чтение)
EXT2

Документация:

Системные вызовы
Ядро
Стандартная библиотека

Вебсайт:

Домен
Движок сайта
Документация
Статьи
Примеры

Примеры:

Пример модуля
Пример драйвера
Пример программы-модуля
Пример модуля ввода-вывода

Видеоуроки:

Основы языка C
Основы ассемблера GAS
Настройка окружения
Сборка из исходного кода
Привет мир!
Написание драйвера

Общая работа:

Ядро
Модули
Драйвера
Документация
Вебсайт
Примеры
Видеоуроки

Второстепенные задачи

Модули:

Отладчик
JavaScript
Lua
SQLite
Криптограф

Драйвера:

PS/2 (Мышь)
SATA (AHCI) (Запись)
SIMD (SSE, SSE2, SSE3, SSE4, AVX) - отдельный драйвер для инициализации SIMD инструкций

Партнеры

ООО "НПО ТЕ-ОН"

Сборка из исходного кода

Ubuntu 18.04+

sudo apt install clang-format python3 git qemu-system-x86 gdisk dos2unix
git clone https://git.synapseos.ru/Aren/BMOSP.git
cd BMOSP/
chmod +x build.sh
./build.sh

ArchLinux

yay -S clang-format
sudo pacman -S python3 git qemu-system-x86
git clone https://git.synapseos.ru/Aren/BMOSP.git
cd BMOSP/
chmod +x build.sh
./build.sh

Запуск

Qemu

Стандартная конфигурация

qemu-system-x86_64 -cpu max -m 1G -smp 1 -bios ovmf/OVMF.fd -hda bmosp.hdd  -name "БМПОС"

Или

chmod +x run.sh
./run.sh

Предупреждение

Использовать на свой страх и риск. Система расчитана на работу в эмулируемой среде Qemu под процессоры x86_64. Мы не несем ответственности за нанесенный ущерб.

Ресурсы

https://vk.com/BMOSP Страница вконтакте
https://t.me/bmosp Телеграм
https://bmosp.ru Вебсайт
https://wiki.synapseos.ru/index.php?title=БМПОС Страница на вики

Зеркала

https://git.synapseos.ru/Aren/BMOSP - доверенный сервер(главный репозиторий)
https://github.com/0Nera/BMOSP - зеркало
https://tvoygit.ru/0Nera/BMOSP - зеркало
https://hub.mos.ru/synapseos/BMOSP - неактивное зеркало

Использованные ресурсы

https://github.com/limine-bootloader/limine (BSD 2-Clause)
https://github.com/nothings/stb (MIT, Общественное достояние)
https://en.wikipedia.org/wiki/CPUID
https://github.com/klange/toaruos (NCSA)
https://wiki.osdev.org/Model_Specific_Registers
https://sandpile.org/x86/msr.htm

dojoengine/dojo-starter

2023-10-25T01:26:15Z

A starting template for your Dojo world

hiredman/elasticsearch-lang-clojure

2023-10-25T01:26:36Z

clojure lang plugin for elasticsearch

odyssomay/orbit

2023-10-25T01:26:36Z

orbit is a clojure wrapper for the java 3d engine jmonkeyengine.

dominicpoeschko/cmake_helpers

2023-10-25T01:26:39Z

nomilous/knax

2023-10-25T01:26:45Z

Dynamic Module Loader

cffi/cffi

2023-10-25T01:26:50Z

Use EEPROM chips as programmable logic

Easily use EEPROMs as programmable logic

Once upon a time in the old world, someone way smarter than me observed that EEPROM memory chips can be used as a programmable logic devices.

You can consider the address pins as input pins, and the data pins as output pins. You can define arbitrarily complex logic expressions for each output pin.

Said even less elegant, whatever logic function you can dream up, as long as its input relies only on the state of the input pins, you can make the EEPROM carry out.

Example

Example: One of each of the common logic gates, just write the generated "gates.bin" to the EEPROM chip and wire it up.

(load "eepromlogic.lisp")
(use-package :eeprom-logic)

(truth nil "gates.bin" 0 65535
       (q (a0 a1) (and a0 a1))          ; Input on A0 and A1. Output on D0
       (q (a2 a3) (or a2 a3))           ; D1
       (q (a4 a5) (xor a4 a5))          ; D2
       (q (a6) (not a6))                ; D3
       (q (a7 a8) (nand a7 a8))         ; D4
       (q (a9 a10) (nor a9 a10))        ; D5
       (q (a11 a12) (xnor a11 a12))     ; D6
       (q () :off)                      ; D7 is always 0
)

This is a simple example. You're not limited to "one gate per output", your expressions can be as complex as you need. See documentation and examples below.

Examples

Intrigued? Read and run the examples.lisp.

The file contains a few examples of gates and other logic, such as 7 bit full adders with different pinouts, and a binary to hex 7 segment display decoder.

sbcl --load "examples.lisp"

Documentation / Reference

The following stuff is made available:

truth - Make truth table
q - Create expression for output bit
ltn - Convert list of booleans to number
btn - Convert boolean to number
nand - 2 input logic
nor - 2 input logicocs below.
xor - 2 input logic
xnor - 2 input logic

Additionally, any LISP function can be used to build expressions.

Which EEPROMs can I use ?

You can use any eeprom arranged into 8 bytes, with up to 20 address, see EEPROM sizes.

In my examples, I'm using an Atmel AT27C512 (64Kx8). Feel free to expand this package to work with 16 bit chips.

How to think about descibing logic

When using this tool, it's helpful to think of what you're doing in a certain way: You are describing a desired output state for a given input state.

Abstract enough for you? Okay, look at some chip, it has input pins and output pins, now, select a couple of input pins, and ONE output pin.

You want to describe the logic that sets the state of that ONE output pin based on those specific input pins. Nothing more, nothing less.

Basically, you will define 8 expressions, one for each output bit, which the "truth" function will then call, once for every possible bit combination, to generate the truth table.

Always think about one output pin at a time.

That might feel constrained but it's not. You're totally free to use as many or as few of the input pins, in whatever combination you want, along with any lisp function, to build your expression.

It's also fine to use the same input pins in the expressions for muliple output pins.

Start by having a look at the truth function and q macro.

Truth

Truth function

The truth function generates the truth table. It can show it on the screen. It can also save it to a binary file, ready to write onto a EEPROM. This is the main function you'll want to call to do anything with this package.

(truth
       show          ; Show truth table on console
       filename      ; Save binary to file
       firstAddr     ; Generate from this address
       lastAddr      ; Generate to this address
       q0            ; Logic expression for EEPROM pin Q0
       q1            ; Logic expression for EEPROM pin Q1
       q2            ; Logic expression for EEPROM pin Q2
       q3            ; Logic expression for EEPROM pin Q3
       q4            ; Logic expression for EEPROM pin Q3
       q5            ; Logic expression for EEPROM pin Q5
       q6            ; Logic expression for EEPROM pin Q6
       q7            ; Logic expression for EEPROM pin Q7
)

show - (t / nil) Show truth table on console so we can see how our expressions behave
filename - (nil / string) If not nil: Save binary output to this filename
firstAddr - Generate from this address (usually 0)
lastAddr - Generate to this address (Usually EEPROM size, see eeprom sizes))

You want "show" to be nil when generating a full truth-table, otherwise it's a lot of output.

If you want to check the output of just a single pattern, you can set "firstAddr" and "lastAddr" to the same value, or a short range covering the patterns you want to check. The #b prefix to a number is convenient, so you can type in the binary pattern you want to see the output for. For example, to check what happens when both A0 and A2 is set, you could set both "firstAddr" and "lastAddr" to #b101

The "q" parameters are lambda functions, but you won't notice that, use the Q macro to write them.

Note: The bit-order of the "truth" function is LSB (least significant bit first) because, I find it's easier to understand that I'm defining the expression for the first bit first and the last bit last... This means that the q0 parameter to "truth" defines the logic behaviour for output bit 0, so it is the rightmost bit in the truth table.

Everywhere else, the bit-order is MSB (most significant bit first).

Truth overview

Truth checks

The truth function will check that all functions returned both t and nil at some point (that they are not always providing the same output), this check will fail if you write some logical error, such as (and a0 (not a0)).

It will often fail when not generating the entire table, so if you expect your check to pass, but it fails, try using the full address range.

If you don't want to implement any behaviour for an output, use the :on or :off symbol, instead of t or nil. This allows the checker to understand that it's intended that those outputs never change.

(q () :off) ; Bit always off

Truth overview

EEPROM Sizes

When generating a binary output file for writing to the EEPROM, be sure to select the correct "firstAddr" and "lastAddr".

"firstAddr" should probably always be 0.

If you set the "lastAddr" value too small, your chip won't be fully programmed any floating address pins may generate wrong results.

If you set the "lastAddr" value too large, the generated binary is too big and won't fit on the chip, you may truncate it, it might or might not work, but the logic check wouldn't have warned you if you requested address bits from pins not actually present on your chip.

An easy way to set the right "lastAddr" is to simply count the address pins on your chip, and punch 1 for every pin, that binary number is your "lastAddr", you can prefix a binary number with #b and use it directly

Example: For a chip with 10 address pins, the "lastAddr" is the binary number "ten ones", so #b1111111111 in binary, #x3FF in hex and 1023 in decimal.

"truth" don't care which representation you use, they're all the same number.

Chip	Size	Arrangement	Available addresses	lastAddr
27080	80 Mbit	1M x 8	A0 to A19	#xFFFFF
27040	40 Mbit	512K x 8	A0 to A18	#x7FFFF
27512	64 Kbit	64K x 8	A0 to A15	#xFFFF
27256	32 Kbit	32K x 8	A0 to A14	#x3FFF
27128	16 Kbit	16K x 8	A0 to A13	#x1FFF
2764	64 Kbit	8K x 8	A0 to A12	#xFFF
2732	32 Kbit	4K x 8	A0 to A11	#x7FF
2716	16 Kbit	2K x 8	A0 to A10	#x3FF
You	get	the	idea	now
2704	4 Kbit	512 X 8	A0 to A8	#xFF

Note: "truth" don't detect if you request address bits for pins not on your chip, those bits will always be set to 0, and your logic will not work.

Truth overview

Package overview

Q

The Q Macro

The Q macro allows you to write a logic expression for an output pin (the data or "Q" pin on the EEPROM chip).

You must provide an expression for each of the q0..q7 parameters that the truth function takes.

Usage:

(q 
       (inputs)
       logic)

Example usage:

(truth t nil 0 3                   ; Show truth table for address 0..3
       (q                          ; Create expression for pin Q0
              (a2 a5)              ; Request the a2 and a5 variables
              (and a2 (not a5)))   ; Implement the expression

       (q                          ; Create expression for pin Q1
              (a1)                 ; Request the a1 variable
              (not a1))            ; Set pin Q1 to the inverse of A1
       
       (q                          ; Create expression for pin Q2
              (a2)                 ; Request a2 variable
              a2)                  ; Set pin Q2 equal to the state of A2
       ;; Snip for brewity, but all 8 Qs must be provided.

The logic expression is evaluated by "truth" for every possible input combination and its resulting state saved in the truth table.

It works by you telling which input bits (address pins on the EEPROM chip) you want to consider in your expression, and an expression that returns the desired state of the output bit based on the state of those input bits.

You can do whatever LISP you want in your expression, but remember each expression is evaluated only once per bitpattern, there's no state to be modified inside the EEPROM.

Your expression must return t or nil.

Here's an example, where we want pins A0, A5 and A10 for some reason, and we want the output bit to be 1 if exactly any two bits are set and 0 otherwise.

We could implement this with pure boolean logic. But all of LISP is available and we can solve it however we please. In this example I convert the boolean state of the pins to numbers (1 or 0) and sum them, if the result is 2, then exactly two of the input pins were high.

(q (a0 a5 a10) ; Request the a0 a5 and a10 variables
       (eq (+ (btn a0) (btn a5) (btn a10)) 2)) ; The logic expression

Remember that you can use the same input in as many of your expressions as you want:

(truth t nil 0 1
       (q (a0 a1) (and a0 a1)) ; q0 - Uses a0
       (q (a1 a2) (and a1 a2)) ; q1 - Also uses a0
       ; ... snip for brewity, all 8 Qs must be provided

Q overview

Q Extra neatness!

Q provides two other inputs, the first is easy to understand: "adr", the integer value on the address bus.

In this example, we want the output pin to be high whever the number present on the bus is in the range 16384..24576

(q (adr) (and (>= adr 16384) (<= adr 24576)))

We can also check for a specific address:

(q (adr) (eq adr 34215))

The adr variable is convenient for creating memory mappers, decoders and bus controllers.

Q overview

Q Brain-melty extra messiness!

The next feature is slightly less obvious: When defining logic expressions for output pins HIGHER than q0, you can also access the output state of all the lower pins!

For q0, there's no extra information, because there is no lower pin.

For q1, you can access the output of q0 through a variable named d0

For q7, you can access the output of q0..q6 through variables d0..d6!

In this example, we define q7, let's say we want q7 to be high if any other pin is high:

(q (d0 d1 d2 d3 d4 d5 d6) (or d0 d1 d2 d3 d4 d5 d6))

You're allowed to mix them all, say this might be for o3

(q (d1 a0 adr) (and (> adr 5) (or d1 a0)))

Q Clarification

The q macro allows you to request for for variables a0..a19 d0..d6 and "adr" to be available in your expression body, and then define a logic expression using those variables to determine the output state for the bit.

"adr" is a number, a0..a19 and d0..d6 are boolean.

Wonder how to tell the q macro which bit you're defining output state for ?

The argument position in the call to "truth" determines this. "truth" calls the every function in order from q0 to q7, first function describes expression for lowest bit, this should be clear if you re-read the truth function description.

Wonder how to tell the q macro that you don't want to implement anything on a pin, and not have the checker tell you about "stuck bits" ? See the truth checks section.

Q overview

Package overview

Ltn

Convert list of booleans representing a binary number to a number, most significant bit first in list.

(ltn (list t t nil)) ; => 6

Package overview

Btn

Convert a single boolean to number.

(btn (nil)) ; => 0
(btn (t))   ; => 1

Package overview

Gates

The gates nand nor xor xnor implement the logic functions they're named after.

They all take exactly two boolean arguemnts and return a boolean value.

(nand t t)
(xor a1 a5)
(nor d1 a6)

Remember, LISP also provides logic functions that you can use, among them are not, and, or, if, eq, >, >=, <=, logbitp and lots of other stuff I don't know about, but as long as it ends up t or nil, it's fine to use.

Package overview

MilanBhanuka/Sample_Codes

2023-10-25T01:27:19Z

zenphoto with info graphic representation

tictail/bounce.js

2023-10-25T01:27:19Z

Create beautiful CSS3 powered animations in no time.

Bounce.js

Bounce.js is a tool and JS library for generating beautiful CSS3 powered keyframe animations. The tool on bouncejs.com allows you to generate static keyframes that can be used without any extra JavaScript, but if you'd like your application to generate these on the fly, you can use the Bounce.js library.

Installation

The library is available to install from Bower or NPM:

$ bower install bounce.js 
# OR
$ npm install bounce.js

You can also view and download all releases from here.

Usage

To create an animation, instantiate a new Bounce object:

var bounce = new Bounce();

The Bounce object is what you'll use to first build your animation from the different components scale, rotate, translate and skew. This can then either be defined as a named animation for later use, or directly applied to elements on the page.

Adding Animation Components

As mentioned above, you'll use the scale, rotate, translate and skew methods to build your animation, just like with the Bounce.js tool. All of these methods accept a number of common options (explained further down) and from and to parameters that define the start and end points of the animation. Note that all of these methods are chainable.

scale

var bounce = new Bounce();
bounce.scale({
  from: { x: 0.5, y: 0.5 },
  to: { x: 1, y: 1 }
});

The from and to parameters define the scale of the element on X (width) and Y (height) as a ratio. The example above animates the element from half size to full. (See it in action)

rotate

var bounce = new Bounce();
bounce.rotate({
  from: 0,
  to: 90
});

The from and to parameters define the rotation of the element in degrees. The example above animates the element a quarter rotation to the right. (See it in action)

translate

var bounce = new Bounce();
bounce.translate({
  from: { x: 0, y: 0 },
  to: { x: 100, y: 0 }
});

The from and to parameters define the translation (position) of the element on X and Y in pixels. The example above animates the element 100 pixels to the right. (See it in action)

skew

var bounce = new Bounce();
bounce.skew({
  from: { x: 0, y: 0 },
  to: { x: 20, y: 0 }
});

The from and to parameters define the skew of the element on X and Y in degrees. The example above animates the skew of the element 20 degrees on the horizontal axis. (See it in action)

Common Animation Parameters

All of the above methods accept these additional parameters:

duration: The duration of the animation in ms. Defaults to 1000.
delay: The delay of the animation in ms. Defaults to 0.
easing: One of "bounce", "sway", "hardbounce", "hardsway". These are the same as in the "Easing" menu in the tool. Defaults to "bounce".
bounces: The number of bounces in the animation. Defaults to 4.
stiffness: The stiffness of the bounces in the animation, should be a value between 1 and 5. Defaults to 3.

Using the Animation

Once you've built your animation, you can either choose to define it as a named keyframe animation, or directly apply it to any element in the DOM.

define

var bounce = new Bounce();
bounce.rotate({
  from: 0,
  to: 90
});
bounce.define("my-animation");

Defines an animation with the given name. The animation can then be used in your CSS with animation: my-animation 1s linear both;.

applyTo

var bounce = new Bounce();
bounce.rotate({
  from: 0,
  to: 90
});
bounce.applyTo(document.querySelectorAll(".animation-target"));
// or with jQuery: bounce.applyTo($(".animation-target"));

Directly applies the animation to a single or a list of elements. This method also accepts a number of options:

loop: Loops the animation infinitely if set to true. Defaults to false.
remove: Removes the animation once it is complete. If your animation ends in a state different from what the element had before, the element will return to its original state in some browsers. Defaults to false
onComplete: A callback function to be run after the animation is complete.

If you're using jQuery, the method will return a promise to be used instead of the onComplete parameter:

bounce.applyTo($(".animation-target")).then(function() { 
  console.log("Animation Complete"); 
});

Remove

An animation can also manually be removed once it has been defined:

bounce.remove()

Browser Support

You can check for support in the current browser with:

Bounce.isSupported()

The library should work in all browser that support both 3D transforms and keyframe animations.

Full Example

Here's a full example of building the Splat animation preset in the tool and applying it to an element with class animation-target.

var bounce = new Bounce();
bounce
  .translate({
    from: { x: -300, y: 0 },
    to: { x: 0, y: 0 },
    duration: 600,
    stiffness: 4
  })
  .scale({
    from: { x: 1, y: 1 },
    to: { x: 0.1, y: 2.3 },
    easing: "sway",
    duration: 800,
    delay: 65,
    stiffness: 2
  })
  .scale({
    from: { x: 1, y: 1},
    to: { x: 5, y: 1 },
    easing: "sway",
    duration: 300,
    delay: 30,
  })
  .applyTo(document.querySelectorAll(".animation-target"));

Developing

If you'd like to run the Bounce.js site locally, and edit the JavaScript library, you can do so by cloning this repo and running the following commands (assuming that you have Node, NPM and Bower installed):

# Install dependencies
$ npm install
$ bower install

# Start the server on localhost:9000. Watches for changes, automatically recompiles files and refreshes the browser.
$ grunt serve 

# Run the tests
$ grunt test

Azure-Samples/azure-sql-db-session-recommender

2023-10-25T01:27:19Z

Build a recommender using OpenAI, Azure Functions, Azure Static Web Apps, Azure SQL DB, Data API builder and Text Embeddings

page_type: sample languages:

csharp
sql
tsql products:
azure-functions
azure-sql-database
static-web-apps
sql-server
azure-sql-managed-instance
azure-sqlserver-vm
dotnet
azure-openai name: Session Recommender using Azure SQL DB, Open AI and Vector Search description: Build a session recommender using Jamstack and Event-Driven architecture, using Azure SQL DB to store and search vectors embeddings generated using OpenAI

Session Recommender Sample

A session recommender built using

For more details on the solution check also the following articles:

Getting Started

Make sure you have AZ CLI installed. It is also recommeneded to use VS Code with the Azure Functions extension installed.

Create the resource group

Create a new resource group using the following command:

az group create -g <your-resource-group-name> -l <location>

Create the Azure OpenAI service

Create a new Azure OpenAI service in the resource group created in the previous step using the following command:

az cognitiveservices account create --name <your-openai-name> --resource-group <your-resource-group-name> --kind OpenAI --sku s0

Create an embedding model using the Azure OpenAI and name it embeddings. Make sure to use the text-embedding-ada-002 mode. Once the resource is created, create a azuredeploy.parameters.json file using the provided sample file and add the API key and the API url. If you want to also test everything locally, also create a .env file from the provided sample and add the API key and url also there.

Deploy the solution

Fork this repository and then clone the forked respository locally.

Deploy the database

Create an new Azure SQL database, then run the ./database/setup-database.sql script to set up the database.

It is recommened to use Azure Data Studio to run the script. Make sure that the SQLCMD mode is enabled. To enable SQLCMD mode, click on the SQLCMD button in the toolbar.

Before running the script set the values for the SQLCMD variable on top of the script:

:setvar OpenAIUrl https://<your-openai-service>.openai.azure.com
:setvar OpenAIKey <your-key>

using the value from the OpenAI service created in the previous step.

Then run the script to create the database objects.

Deploy Static Web App and Azure Function

Replace the placeholders values in the azuredeploy.parameters.json file with the correct values for your environment. Follow the documentation here: Managing your personal access tokens to get the GitHub token needed to deploy the Static Web App. Make sure the token created is a "classic" token that has access to the following scopes: repo, workflow, write:packages

Then run the following command to create the resources in Azure.

az deployment group create --resource-group <your-resource-group-name> --template-file main.bicep --parameters azuredeploy.parameters.json

The deployment process will create

Static Web App
Function
Storage Account
Application Insight

The deployment process will also automatically deploy the code of the referenced repository intpo the created Static Web App.

Configure the Static Web App

Now that the Static Web App has been deployed, it needs to be linked the Static Web App to the created database using the Database Connections feature. Follow the instructions in the Configure database connectivity to configure the database connection.

Deploy the Azure Function

To upload the Azure Function code to Azure it is recommeded to use Visual Studio Code, and the Azure Function extension: right click on the /func folder, select "Deploy to Function App" and then select the function app that has was created in 'Deploy Static Web App and Azure Function' step.

Another option is to use AZ CLI. First build the function:

cd func
dotnet publish

and then compress the content of the publish folder (sample for PowerShell):

Compress-Archive .\bin\Debug\net6.0\publish\* SessionProcessor.zip

and the depoy it via AZ CLI:

az functionapp deploy --clean true --src-path .\SessionProcessor.zip -g <resource-group> -n <function-app-name>

Note: Azure function must be deployed as a stand-alone resource and cannot be deployed as a managed function within the Static Web App. Static Web Apps managed functions only support HTTP triggers.

Test the solution

Add a new row to the Sessions table using the following SQL statement:

insert into web.sessions 
    (title, abstract)
values
    ('Building a session recommender using OpenAI and Azure SQL', 'In this fun and demo-driven session you’ll learn how to integrate Azure SQL with OpenAI to generate text embeddings, store them in the database, index them and calculate cosine distance to build a session recommender. And once that is done, you’ll publish it as a REST and GraphQL API to be consumed by a modern JavaScript frontend. Sounds pretty cool, uh? Well, it is!')

immediately the deployed Azure Function will get executed in response to the INSERT statement. The Azure Function will call the OpenAI service to generate the text embedding for the session title and abstract, and then store the embedding in the database, specifically in the web.session_abstract_embeddings table.

select * from web.session_abstract_embeddings

You can now open the URL associated with the created Static Web App to see the session recommender in action. You can get the URL from the Static Web App overview page in the Azure portal.

Run the solution locally

The whole solution can be executed locally, using Static Web App CLI and Azure Function CLI.

abuanwar072/Smart-Home-Animated-App-using-Flutter

2023-10-25T01:27:47Z

A scalable Flutter app template that uses flutter_bloc and go_router. Save weeks of work for your next Flutter app 🚀

Scalable Flutter App Starter

👋 Hey, welcome to Scalable Flutter App.

Watch/star this repo to be notified when updates are pushed.

What is Scalable Flutter App?

Scalable Flutter App is a starter template for Flutter apps.

It's designed to be scalable and easy to maintain. And should save you weeks of development time.

To get started, click on the green "Use this template" button on the top-right.

About the Author

I'm Milos Jokic and I:

built my first mobile app in 2007
grew my apps to 214k users and $106,140 revenue.
built apps for 10 Toptal clients.

And now I run a 6-figure devs agency where we launch MVPs in 4 weeks using Flutter & Firebase.

You can find me on:

Features

Feature	Starter	Pro
Platforms: Android, iOS, web	✅	✅
Scalable Architecture using flutter_bloc	✅	✅
Navigation using go_router	✅	✅
Scalable App Styling	✅	✅
GitHub Actions - code and formatting check	✅	✅
Responsive Design	✅	✅
UserMockProvider	✅	✅
Profile Page	✅	✅
Settings Page: sign out, app version...	✅	✅
Legal: Terms, Policy, Data Deletion	✅	✅
Google Fonts	✅	✅
Sign in and Sign Up Pages	✅	✅
Input Validators	✅	✅
Cached network image	✅	✅
Email Support	❌	✅
Lifetime Updates	❌	✅
Firebase Project Integration	❌	✅
Firebase Authentication	❌	✅
Firebase Remote Config	❌	✅
Firebase Crashlytics	❌	✅
Firebase Firestore	❌	✅
Firebase Analytics	❌	✅
Firebase Storage	❌	✅
Google Sign In	❌	✅
Apple Sign In	❌	✅
Email Link Sign In	❌	✅
Common Cubits	❌	✅
In App Purchases (RevenueCat)	❌	✅
App Store Review Request	❌	✅
Notifications (Firebase)	❌	✅
HTTP Requests	❌	✅
Local Storage	❌	✅
Permissions	❌	✅
Environments	❌	✅
Localization	❌	✅
Dark Mode	❌	✅
Connectivity check	❌	✅
Hive - local database	❌	✅
MixPanel - analytics	❌	✅
Android - Release Signing	❌	✅
Onboarding	❌	✅
Forgot Password	❌	✅
🎉 BONUS: Scalable Firebase Backend Template	❌	✅

Pro Presale Discount

Get Your Scalable Flutter App PRO for $47 ($200 OFF) Here

$200 off discount code (APP200) lasts until end of October.

Scalable Flutter App - Pro launches in November.

Docs

Code Architecture

The code architecture is based on flutter_bloc architecture proposal.

There are 4 layers:

UI (Flutter Widgets)
BLoC (stateful business logic)
Repository (high-level API)
Provider (low-level implementation)

And there's only 1 communication rule that we must follow:

The layer can only call the one layer below it.

That means that:

UI can only call BLoC
BLoC can only call Repository
Repository can only call Provider
Provider can only call external services (Firebase, HTTP, etc.)

And we avoid same-layer communication (as it creates interdependencies):

UserRepository calling AuthRepository is not allowed.
UserCubit calling UserRepository and AuthRepository is allowed.

Styling

Styling is based on Google's Material Design.

App-wide styling is defined in core/app/style.dart and is easy to update.

Here's a quick tip on custom Widget params. There are 2 Widget param types:

data (user, title, ...)
style (colors, paddings, ...)

Our custom Widgets should only hava data params.

And the style should be done app-wide (in style.dart).

That way all of our UI is consistent and easy to update.

Google Fonts

To change the font:

Go to Google Fonts and select a font.
Download the font files.
Add the font files to assets/fonts (remove the old ones).
Update style.dart with the new font (i.e. return GoogleFonts.rubikTextTheme(textTheme)).

Useful GitHub Pull Request Settings

I've found that turning on these 2 settings in GitHub repo settings helps a lot:

Always suggest updating pull request branches
Automatically delete head branches

FAQ

Why bloc and not X?

While GetX, Provider, Riverpod, MobX, Redux, etc. are all great solutions, most of them are too forgiving. They allow us to access and change state globally.

Whereas flutter_bloc forces us to have BuildContext in order to access and change the state. The stricter the rules, the harder it is to make mistakes.

And flutter_bloc has a great architecture proposal that scales well.

Who is Scalable Flutter App for?

Scalable Flutter App is for developers, agencies, and founders who want to:

build scalable Flutter apps
save weeks of development time
learn best practices

Where to learn Flutter basics?

I can only recommend what I've used myself:

Flutter Codelabs
Flutter YouTube
Effective Dart
and just keep building apps and getting better with each one :)

What if I want more?

If you want Firebase integration, notifications, in-app purchases and more, you can get the Pro version here ($200-off discount lasts until end of October):

Get Your Scalable Flutter App PRO for $47 ($200 OFF)

Resources

Build your app icon in minutes (free): Icon Kitchen

CI/CD for mobile apps (free & paid): Codemagic

Want me to launch your MVP in 4 weeks (premium)? Go to App Launch Program

Need a Flutter Expert (paid)? Go to Flutter Devs Board

Feedback

Found an issue or want to request a feature? Open an issue

Have a question? Ask me on LinkedIn or Twitter.

einsitang/sudoku-flutter

2023-10-25T01:27:47Z

A open source Sudoku game application powered by Flutter . you can build the Sudoku Game just for your own.

Sudoku

about

A open source Sudoku game application powered by Flutter .

you can build the Sudoku Game just for your own.

Download apk for android (preview) -> github release page

screenshots

plan-to-do

[‼] sudoku solver with camera scan

environment

dart SDK: '>=2.18.6 <3.0.0' // Null-Safety
flutter SDK: '^3.0.0'
jdk 11

dependency

sudoku_dart (sudoku core opensource lib )
Hive
scoped_model
logger
sprintf

platform support

android
iOS
~~WEB (no plan support yet)~~

install

$> flutter pub get
# options,when you change the lib/state/sudoku_state.dart file,make sure build hive adapter for the project
$> flutter packages pub run build_runner build

run

$> flutter devices
1 connected device:

iPhone SE (2nd generation) (mobile) • 09684738-362A-468F-80F2-1824A785D324 • ios • com.apple.CoreSimulator.SimRuntime.iOS-13-6 (simulator)

$> flutter run -d 09684738-362A-468F-80F2-1824A785D324

pre-for-build

android

create a keystore for apk signature

On Windows

keytool -genkey -v -keystore c:\Users\USER_NAME\key.jks -storetype JKS -keyalg RSA -keysize 2048 -validity 10000 -alias key

On Mac/Linux

keytool -genkey -v -keystore ~/key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias key

copy ./android/key.properties.example and rename to ./android/key.properties that contains a reference to your keystore

more information pls reference official website : https://flutter.dev/docs/deployment/android

iOS

in Xcode,open ./ios/Runner.xcworkspace to view your app's settings

select the Runner project in the Xcode project navigator. then in the main view sidebar,select the Runner target and select the Identity tab,in the Signing section change Team and Bundle Identifier

more information pls reference official website : https://flutter.dev/docs/deployment/ios

build

# iOS
$> flutter build iOS
# android
$> flutter build apk

more flutter features

see the Flutter official website

the end

thanks for visit this repository , wish you can like it and star it 😘

xmartlabs/xmartchat

2023-10-25T01:27:47Z

Serverless Messaging App Demo for Supabase Workshop. Exploring the Serverless World: An Introduction with Supabase.

Workshop Details:

Welcome to Xmartchat, a dynamic messaging application developed with Flutter and powered by Supabase, designed specifically as a demonstration for our Supabase workshop. This app serves as an exemplar of the potential of serverless architecture, showcasing how serverless technologies, particularly Supabase, can revolutionize the way we build real-time communication applications.

Purpose

Xmartchat acts as a hands-on, interactive showcase during our workshop, highlighting the power and flexibility of serverless computing. Through this demo app, participants will:

Learn Serverless Principles: Understand the fundamental concepts behind serverless architecture and its advantages in modern app development.
Explore Supabase Features: Discover how Supabase simplifies database management, authentication, and real-time data synchronization.
Experience Real-Time Communication: Interact with Xmartchat's real-time messaging capabilities to witness serverless technology in action.
Inspire Innovation: Use Xmartchat as a foundation for experimenting with serverless concepts, encouraging innovative thinking and development.

Workshop requirements

To effectively engage with the Xmartchat demo app and our Supabase workshop, please ensure you have the following:

Flutter Installation: Make sure you have Flutter installed on your system. If not, you can follow the official Flutter installation guide: Flutter Installation Guide
Dart & Flutter Knowledge: Familiarity with Dart programming language and Flutter framework is essential. If you are new to Dart and Flutter, consider going through the official documentation and tutorials to strengthen your skills.
Integrated Development Environment (IDE): You'll need an IDE for Flutter development. We recommend using either Visual Studio Code (VS Code) or Android Studio. Choose the one you are most comfortable with and ensure it's properly set up for Flutter development.

Repo Structure

'mobile': This folder contains all the Flutter code for the mobile application, including the user interface and frontend functionality.
'backend': In this directory, you'll discover the edge functions developed using Supabase, which power the backend operations of the Xmartchat application.
'solution': Within this folder, you'll find the solution of the workshop!

Join the Xmartlabs Community!

At Xmartlabs we love to share our knowledge through our open source work. Feel free to check out our GitHub profile and contribute in any way you see fit. You can also explore our blog, where we regularly post new insights and discoveries. See you there!

yuuki-nya/chronocat-docker

2023-10-25T01:28:10Z

本仓库是学习docker的打包与自动化构建，请下载后24小时内删除

chronocat-docker

本仓库是学习docker的打包与自动化构建，请下载后24小时内删除

使用

快速运行

docker run -d --name chronocat-docker -e VNC_PASSWD=vncpasswd -p 5500:5500 -p 5900:5900 -p 6081:6081 -p 16530:16530 -v ${PWD}/config:/root/.chronocat/config yuukinya/chronocat-docker

其中vncpasswd换成你的VNC密码

或者下载代码中的docker-compose.yml，然后执行

docker-compose up -d

数据固化（可选）

先完成上面的快速运行，保证容器在运行状态

# 进入项目目录
mkdir data
# 复制数据到data目录
docker cp chronocat-docker:/root/.config/QQ ./data

如果之前是docker run运行的，执行

docker run -d --name chronocat-docker -e VNC_PASSWD=vncpasswd -p 5500:5500 -p 5900:5900 -p 6081:6081 -p 16530:16530 -v ${PWD}/config:/root/.chronocat/config -v ${PWD}/data/QQ:/root/.config/QQ yuukinya/chronocat-docker

如果之前是docker-compose运行的，编辑docker-compose.yml，把volumes下两行的开头注释去掉，保存，再执行

docker-compose up -d

noVNC登陆

浏览器访问http://服务器IP:6081，默认密码是vncpasswd

VNC登陆

使用VNC软件登陆服务器IP:5900，默认密码是vncpasswd

修改chronocat配置

修改当前目录/config/chronocat.yml，修改后重启容器即可

修改VNC密码

docker exec chronocat-docker sh -c "x11vnc -storepasswd newpasswd /root/.vnc/passwd"

其中newpasswd换成你的新密码，立即生效，无需重启容器

如何更新

本镜像一般不会只更新chronocat，如果需要只更新chronocat可以使用LiteLoaderQQNT自行更新

更新前请做好数据备份，比如数据固化

删除容器并删除镜像，下面是代码示例

docker rm -f chronocat-docker && docker rmi yuukinya/chronocat-docker

重新pull最近镜像
```
docker pull yuukinya/chronocat-docker
```
按照前面的使用教程操作

已知问题

容器重启后，桌面的任务栏可能会消失，如果触发了请不要缩小或者点叉关闭，建议保持在聊天的界面，再关闭VNC远程
合并转发不可用在Linux版本

TODO

能固化已登陆的数据
使用docker的environment来指定VNC密码

更新日志

2023-10-19

更新chronocat至0.0.54

2023-10-17

更新chronocat至0.0.53

2023-10-13

更新chronocat至0.0.52
新增satori默认端口

2023-10-3

更新chronocat至0.0.48
使用docker的environment来指定VNC密码 Issue #2
新增noVNC，使用浏览器来登陆VNC Issue #2

感谢 ZGLinus提供的思路和代码

2023-9-25

更新chronocat至0.0.46
修改chronocat配置映射至宿主机
固化已登陆数据 Issue #1

2023-9-22

初始版本

WCGKING/BRANDED-VPS

2023-10-25T01:28:10Z

BRANDED-VPS

🍁 𝐓𝐡𝐞 𝐍𝐞𝐰 𝐒𝐞𝐫𝐯𝐞𝐫 📡 𝗕𝗥𝗔𝗡𝗗𝗘𝗗 𝗦𝗨𝗣𝗣𝗢𝗥𝗧 𝐂𝐫𝐞𝐚𝐭𝐞𝐝 𝐀𝐧𝐝 💞 𝐌𝐚𝐧𝐚𝐠𝐞𝐝 𝐁𝐲 » 𝗕𝗥𝗔𝗡𝗗𝗘𝗗 𓆩🇽𓆪 𝗞𝗜𝗡𝗚 ✨

𝐑𝐞𝐪𝐮𝐢𝐫𝐞𝐝 𝐂𝐨𝐧𝐟𝐢𝐠 𝐕𝐚𝐫𝐢𝐚𝐛𝐥𝐞 ...

NGROK_TOKEN

samirm00/fake-store-api

2023-10-25T01:29:13Z

bmuller/telemetry_metrics_cloudwatch

2023-10-26T01:26:35Z

Provides an AWS CloudFront reporter for Elixir Telemetry.Metrics definitions

tanaka51/dot.emacs.d

2023-10-26T01:26:41Z

emacs.d

My .emacs.d

Environment

GNU Emacs 24.2
Macbook Air 13'
cmigemo

Target

Ruby on Rails with CoffeeScript and Sass
Markdown for my blog using Octopress ( http://blog.tanaka51.jp )
under Git project

TODO

Extract files from init.el for paths and window size

vmagnin/forcolormap

2023-10-26T01:27:14Z

A small Fortran fpm library for colormaps

BL-MSCH-C220/Exercise-4-3-Levels

2023-10-25T01:30:22Z

Exercise for MSCH-C220

ivoyager/planetarium

2023-10-25T01:30:22Z

TF2's Rocket Jumping demo

aperturerobotics/bifrost

2023-10-25T01:30:46Z

Cross-platform p2p daemon and library with pluggable transports and WebAssembly support.

Introduction

Bifrost is a peer-to-peer communications engine with pluggable transports:

Cross-platform: supports web browsers, servers, desktop, mobile, ...
Efficient: multiplex many simultaneous streams over a single Link.
Encryption: identify, authenticate, and encrypt each Link between peers.
Flexible: use multiple transports, protocols, simultaneously.
Meshing: supports multi-hop routing to a desired target peer w/ circuits.
PubSub: publish/subscribe channels with pluggable implementations.
Robust: uses Quic for reliable connections over lossy transports.

Bifrost uses ControllerBus controllers and directives to manage links between peers, transports, routing, and other higher-level processes with extensive and flexible configuration.

Overview

Bifrost is designed around the following core concepts:

Peer: a routable process or device with a keypair.
Transport: a protocol which can create Links with other peers.
Link: a connection between two peers over a Transport.
Stream: channel of data between two Peer with a protocol type.
RPC: request/reply and bidirectional streaming remote calls.
PubSub: at-least-once delivery of messages to named topics.

Integrates with networking, pubsub, and RPC libraries like libp2p, noise, drpc, starpc and nats.

The network simulator, testbed, and in-proc transport can be used to write end-to-end tests as Go unit tests. The mock transports use identical code to the real transports, and appear the same to the application code.

The http packages provide a http server and a mechanism for attaching http handlers to the controller bus and using them to serve requests. There is also an implementation of attaching and looking up http clients on the bus.

EntityGraph exposes the internal state representation of Bifrost to visualizers and instrumentation via a graph-based inter-connected entity model.

Configuring each component as an independent controller makes it easy to adapt application code to different operating environments and protocols.

Examples

Bifrost can be used as either a Go library or a command-line / daemon.

The examples directory contains yaml files to configure the daemon, as well as "toys" which are self-contained Go program examples.

To install the CLI and daemon:

# Clone the repo and install.
git clone https://github.com/aperturerobotics/bifrost
cd ./bifrost/cmd/bifrost
go install -v

# Alternatively:
# Note: this currently fails on go >= 1.16 due to replace directives.
# See: https://github.com/golang/go/issues/44840
GO111MODULE=on go install -v github.com/aperturerobotics/bifrost/cmd/bifrost@master

Access help by adding the "-h" tag or running "bifrost help."

As a basic example, launch the daemon:

bifrost daemon \
  --write-config \
  --hold-open-links \
  --pubsub nats  \
  --api-listen :5110 \
  --udp-listen :5112

YAML Configuration

An example of a ConfigSet in YAML format for the daemon: bifrost_daemon.yaml:

# Start a UDP listener on port 5112.
my-udp:
  id: bifrost/udp
  config:
    listenAddr: :5112

# Use the floodsub driver for PubSub.
pubsub:
  id: bifrost/floodsub
  config: {}

Daemon CLI

The Bifrost daemon is configured with a YAML ConfigSet and/or via the API.

NAME:
   bifrost daemon - run a bifrost daemon

OPTIONS:
   --hold-open-links         if set, hold open links without an inactivity timeout [$BIFROST_HOLD_OPEN_LINKS]
   --websocket-listen value  if set, will listen on address for websocket connections, ex :5111 [$BIFROST_WS_LISTEN]
   --udp-listen value        if set, will listen on address for udp connections, ex :5112 [$BIFROST_UDP_LISTEN]
   --xbee-device-path value  xbee device path to open, if set [$BIFROST_XBEE_PATH]
   --xbee-device-baud value  xbee device baudrate to use, defaults to 115200 (default: 115200) [$BIFROST_XBEE_BAUD]
   --establish-peers value   if set, request establish links to list of peer ids [$BIFROST_ESTABLISH_PEERS]
   --xbee-peers value        list of peer-id@address known XBee peers [$BIFROST_XBEE_PEERS]
   --udp-peers value         list of peer-id@address known UDP peers [$BIFROST_UDP_PEERS]
   --websocket-peers value   list of peer-id@address known WebSocket peers [$BIFROST_WS_PEERS]
   --pubsub value            if set, will configure pubsub from options: [floodsub, nats] [$BIFROST_PUBSUB]
   --config value, -c value  path to configuration yaml file (default: "bifrost_daemon.yaml") [$BIFROST_CONFIG]
   --write-config            write the daemon config file on startup [$BIFROST_WRITE_CONFIG]
   --node-priv value         path to node private key, will be generated if doesn't exist (default: "bifrost_daemon.pem") [$BIFROST_NODE_PRIV]
   --api-listen value        if set, will listen on address for API connections, ex :5110 (default: ":5110") [$BIFROST_API_LISTEN]
   --prof-listen value       if set, debug profiler will be hosted on the port, ex :8080 [$BIFROST_PROF_LISTEN]

These CLI flags are provided for convenience to quickly configure a daemon, and the resulting config can be written to a file with --write-config for further adjustments to be made. Note, however, that additional controllers are available which are not yet exposed via these flags.

Client CLI

Most Bifrost functionality is exposed on the client CLI and RPC API:

Mount a peer by loading a private key into the daemon.
Forward incoming streams with a protocol ID to a multiaddress
Proxy incoming connections to a listener to a remote peer
Open a stream with a remote peer and a given protocol ID
Accept a stream for a local peer with a given protocol ID

The client CLI has the following help output:

bifrost client command [command options] [arguments...]

COMMANDS:
   local-peers           returns local peer info
   identify              Private key will be loaded with a peer controller
   subscribe             Subscribe to a pubsub channel with a private key or mounted peer and publish base64 w/ newline delim from stdin.
   forward               Protocol ID will be forwarded to the target multiaddress
   accept                Single incoming stream with Protocol ID will be accepted
   dial                  Single outgoing stream with Protocol ID will be dialed
   listen                Listen on the multiaddress and forward the connection to a remote stream.
   controller-bus, cbus  ControllerBus system sub-commands.

With the above operations, all stream handling and interaction with the network is exposed to the API and command line. Some examples:

  # Note: you can edit bifrost_daemon.yaml to change settings.
  # Once the daemon configuration exists, you can now just run:
  bifrost daemon

  # While the command is executing, the private key will be attached.
  bifrost client identify --peer-priv priv-key.pem

  # While the command is executing, a forwarding controller will be running.
  # Protocol ID will be forwarded to the target multiaddress
  # Handles HandleMountedStream directives by contacting the target.
  # HTTP can be easily proxied through an encrypted stream this way.
  bifrost client forward \
    --peer-id <agent-id> \
    --protocol-id /x/myproto \
    --target /ip4/127.0.0.1/tcp/8000

  # While the command is executing, a proxying controller will be running.
  # Protocol ID will be proxied from the listen multiaddress to the target peer.
  # Calls OpenStream to build a stream from <source-peer-id> to <target-peer-id>.
  # HTTP can be easily proxied through an encrypted stream this way.
  bifrost client listen \
    --peer-id <target-peer-id> \
    --from-peer-id <source-peer-id> \
    --protocol-id /x/myproto \
    --listen /ip4/127.0.0.1/tcp/8001

  # Wait for a stream to be opened to the mounted peer with the protocol ID /x/myproto
  # Standard output is the incoming data stream, standard input is the outgoing data stream.
  # Standard error is used for logging.
  bifrost client accept \
    --local-peer-id <peer-id> \
    --protocol-id /x/myproto 

  # Establish a stream.
  # Standard output is the incoming data stream, standard input is the outgoing data stream.
  # Standard error is used for logging.
  bifrost client dial \
    --peer-id <target-peer-id> \
    --local-peer-id <local-peer-id> \
    --protocol-id /x/myproto

Example: forward HTTP traffic between peers

The following is a basic example of using the CLI to forward encrypted traffic between a local port and a remote peer port, similar to SSH port forwarding:

  # note the peer id in the logs
  ./bifrost daemon \
            --write-config \
            --udp-listen :5000 \
            --node-priv daemon_node_priv_2.pem \
            --websocket-listen ":5111" \
            --prof-listen ":6201"

  # forward incoming connections to port 8000
  # example: "python3 -m http.server 8080"
  ./bifrost client forward \
            --protocol-id "test/protocol" \
            --target /ip4/127.0.0.1/tcp/8000

  # replace PEER-ID-HERE with the peer ID from the first daemon.
  # start a second daemon (in a new shell).
  ./bifrost daemon \
            --udp-listen :5001 \
            --udp-peers "PEER-ID-HERE@127.0.0.1:5000" \
            --api-listen ":5112"

  # tell it to listen on port 8082 and forward to the other peer.
  # try browsing to http://localhost:8082
  ./bifrost client --dial-addr 127.0.0.1:5112 listen \
            --peer-id "PEER-ID-HERE" \
            --protocol-id test/protocol \
            --listen /ip4/127.0.0.1/tcp/8002

This example shows how to run two daemons with information on how to contact each other, and then "tell" the second daemon to listen on port 8002 and forward any incoming connections to the remote peer with the given peer ID.

When someone connects to port 8002 the EstablishLinkWithPeer directive is added and the UDP transport opens the connection with the peer (on-demand.) The stream is then negotiated. The remote daemon uses HandleMountedStream which is handled by the "forwarding" controller, which forwards the stream to localhost at 8000.

Transports and Links

A Link is a packet stream between two Peer. Links are created by Transports, which are associated with a local private keypair.

Transports are responsible for handshaking their identity and providing stream multiplexing, encryption, and ordering. The Bifrost codebase contains common implementations for packet-based and stream-based transports, based primarily on the quic-go implementation of the Quic UDP protocol.

The HandleMountedStream directive contains incoming protocol and peer info. The appropriate controller for the protocol responds to the directive and handles the incoming stream. This decouples the transport layers from the protocols.

PubSub

A PubSub is a controller that supports topic-based at-least-once delivery.

Nats and floodsub are currently supported as PubSub protocols.

Support

Please open a GitHub issue with any questions / issues.

... or feel free to reach out on Matrix Chat or Discord.

License

Apache 2.0

jschen3/bety-ui

2023-10-26T01:28:24Z

repository for development of site redesign

seqeralabs/wave

2023-10-26T01:28:27Z

On-demand containers provisioning service

marianolabarinas/dynamic-parameters

2023-10-26T01:28:27Z

dynamic-parameters

surajsharma14/Web-Dev-Project-for-Hacktoberfest2023

2023-10-25T01:32:04Z

HacktoberFest 2023 `GOOD FIRST` Pull Request - `Digital Rewards`🎉

Contributors to Hacktoberfest 2023

The Open Source Adventure Awaits! 🗺️

🌐 HacktoberFest is your gateway to the vibrant world of open source. This year marks the 10th anniversary of Hacktoberfest, and we’re calling on your support! Join us on this epic journey and earn yourself an exclusive digital reward kit from DigitalOcean and our sponsors and partners..

📢 Sign up for Hacktoberfest 2023, and contribute four pull requests (PRs) between October 1st-31st to claim your stash of cool SWAGS 🔥.

[Visit this repository to contribute to a new project for Hacktoberfest 2023]

3kh0/website-v4

2023-10-26T01:28:59Z

3kh0, the better unblocked games website. If you fork this repo please give me a star to support me.

This website has been shutdown.

Hello everyone,

I hope you all are doing well. I have some sad news to bring to you all. 3kh0.net will be shutting down, effective immediately. This was not a choice made lightly, and I would HIGHLY recommend that you read this document about why and the future of it: https://rentry.co/3kh0. I also suggest that you join the discord server as we will have more stuff planned there. Thank you.

3kh0

The better unblocked games website.

This is the GitHub repo which is used to host the website. If you want to use the games on here on your website, please message me on discord at 3kh0_#6969 and we can talk! If you're looking for the link, click here

Note If you do fork this repo, please give the orginal repo a star! It helps out alot and only 30% of people who fork give me a star.

Features

Site-wide tab cloaking
Easy to deploy
Clean UI
Cross platform
Easy to use
Light on host resources (For real this time)
And so much more!

Note If you have any problems please open an issue, so we can fix it ASAP!

Game Files

Due to the amount of games, all of the games have been moved to a new repo.

Host the CDN

Thanks to @Russell2259 you can host your own 3kh0 CDN, instructions are located here.

Host the website

You can host our website on a cloud hosting solution like Replit or Render here. If you're unsure on what this does, use our own site, or find one someone else is hosting.

Docs

The official 3kh0 docs can be found here. If you want to make a theme this is the place!

Contributors

Thank you to all of these amazing people for helping work on this project!

There are more contributors but they are listed on the website

And the people who worked on v3!

And the people who worked on v2!

There are more contributors then the ones shown.

And the people who worked on v1!

Contributing

Contributions are always welcome!

See contributing.md for ways to get started.

Please adhere to this project's Code of Conduct.

If you would like to help add games, you can do that here: 3kh0/3kh0-Assets, this repo only has the UI and other things

Run Locally

First clone the project using command line

git clone https://github.com/3kh0/website-v4.git

or if you have GitHub CLI

gh repo clone 3kh0/website-v4

Since this project does not require a backend, for the best experience I suggest using XAMPP, cloning the repo into the Apache Server directory at C:\xampp\htdocs (for windows) or /opt/lampp/htdocs (for linux), setting the port to something like 8080, opening up a browser and going to localhost:8080

You could also use something like http-server. You will need to have NodeJS installed also.

Running (npx)

npx http-server

Running (installing to global node_modules)

# Install
npm install -g http-server

# Running
http-server

Warning Cloning a repository with Git removes everything in the folder you do it in. If you're not careful, you can delete your hard drive, so please do not do this unless you know what you're doing.

License

View the full license here

Previous versions

Here are some of the previous versions of this project. To give you a sense, this is v4

johnwickerson/HSV

2023-10-25T01:32:46Z

jar-analyzer/jar-analyzer

2023-10-26T01:29:53Z

Jar Analyzer Project

Jar-Analyzer V2

Jar Analyzer 是一个分析 Jar 文件的 GUI 工具：

方便地搜索方法之间的调用关系
方便地搜索 Jar 文件中的字符串
一键分析 Spring Controller/Mapping
对于方法字节码/指令等高级分析
一键反编译

相比 Jar-Analyzer V1 在 V2 版本中解决了很多重要问题：

中文不再乱码，代码 GUI 部分更美观
支持大 Jar 文件以及批量分析
支持保存状态，重启还原上次分析内容

另外有很多改进功能：

更好的 GUI 界面，代码高亮改进
文件树改进，按照文件夹以及字母排序
反编译改进，优化对内部类的处理
自动搜索 rt.jar 并加入分析
一键查看任意方法的 Control Flow Gragh
一键查看任意方法的 Stack Frame 分析

更多的功能正在开发中

有问题和建议欢迎提 issue

前往下载

一些截图

指令分析

CFG 分析

JVM Stack Frame 分析

分析 Spring Framework

首页

方法调用搜索

方法调用关系

高级分析：正在开发中

注意事项

本工具已经根据 1080P 适配（考虑到绝大多数机器应该大于等于这个分辨率）

如果你的电脑在 1080P 下无法正常显示，请调整缩放到 100%

以 Windows 11 为例：右键显示设置

本工具的基本原理：

解压所有 Jar 文件到 jar-analyzer-temp 目录
在当前目录构建数据库 jar-analyzer.db 文件
在当前目录新建文件 .jar-analyzer 记录状态

注意：当 Jar 数量较多或巨大时可能导致临时目录和数据库文件巨大

Release 说明

在 release 中提供四种下载：

system 使用系统 JDK/JRE 的启动脚本 (需要自行安装 JRE)
embed 内置安全 Y4 JRE 的启动脚本 (无需另外安装一键启动)
linux 内置 shell 启动脚本 (需要自行安装 JRE)
简单的 Jar 文件，不提供启动脚本

由于本工具仅在 Windows 中测试，其他操作系统可能会有未知的问题

一般情况下，推荐使用内置 Y4 JRE 的 embed 版本启动

关于 Y4 JDK/JRE 项目: https://y4sec-team.github.io/jdk8u/

如何构建

项目主要基于 Java 8

下载 JDK 8 (推荐 https://github.com/Y4Sec-Team/jdk8u)
使用 Maven (https://maven.apache.org/download.cgi)
使用 Python 3 辅助 (https://www.python.org/downloads/)

步骤：

(1) mvn -B package -Dmaven.test.skip=true --file pom.xml

(2) python build.py

(3) 复制 JRE 到 embed 版

其他

如果你希望体验老版本 (不再维护) 的 Jar Analyzer 可以访问：

为什么我不选择 IDEA 而要选择 Jar Analyzer V2 工具：

因为 IDEA 不支持分析无源码的 Jar 包
本工具有一些进阶功能是 IDEA 不支持的 (指令/CFG/Stack分析)

(1) 什么是方法之间的关系

class Test{
    void a(){
        new Test().b();
    }
    
    void b(){
        Test.c();
    }
    
    static void c(){
        // code
    }
}

如果当前方法是 b

对于 a 来说，它的 callee 是 b

对于 b 来说，它的 caller 是 a

(2) 如何解决接口实现的问题

class Demo{
    void demo(){
        new Test().test();
    }
}

interface Test {
    void test();
}

class Test1Impl implements Test {
    @Override
    public void test() {
        // code
    }
}

class Test2Impl implements Test {
    @Override
    public void test() {
        // code
    }
}

现在我们有 Demo.demo -> Test.test 数据, 但实际上它是 Demo.demo -> TestImpl.test.

因此我们添加了新的规则： Test.test -> Test1Impl.test 和 Test.test -> Test2Impl.test.

首先确保数据不会丢失，然后我们可以自行手动分析反编译的代码

Demo.demo -> Test.test
Test.test -> Test1Impl.test/Test.test -> Test2Impl.test

(3) 如何解决继承关系

class Zoo{
    void run(){
        Animal dog = new Dog();
        dog.eat();
    }
}

class Animal {
    void eat() {
        // code
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        // code
    }
}

class Cat extends Animal {
    @Override
    void eat() {
        // code
    }
}

Zoo.run -> dog.cat 的字节码是 INVOKEVIRTUAL Animal.eat ()V, 但我们只有这条规则 Zoo.run -> Animal.eat, 丢失了 Zoo.run -> Dog.eat 规则

这种情况下我们添加了新规则： Animal.eat -> Dog.eat 和 Animal.eat -> Cat.eat

首先确保数据不会丢失，然后我们可以自行手动分析反编译的代码

Zoo.run -> Animal.eat
Animal.eat -> Dog.eat/Animal.eat -> Cat.eat

致谢

感谢以下项目提供的思路和代码

ErickWendel/semana-javascript-expert08

2023-10-26T01:30:08Z

JS Expert Week 8.0 - 🎥Pre processing videos before uploading in the browser 😏

JSExpertHub Pre-processing videos on browsers - Semana JS Expert 8.0

Seja bem vindo(a) à oitava Semana Javascript Expert. Este é o código inicial para iniciar nossa jornada.

Marque esse projeto com uma estrela 🌟 e acesse o nosso grupo oficial no WhatsApp

Preview

Pre-reqs

Este projeto foi criado usando Node.js v18.17.0
O ideal é que você use o projeto em ambiente Unix (Linux). Se você estiver no Windows, é recomendado que use o Windows Subsystem Linux pois nas aulas são mostrados comandos Linux que possam não existir no Windows.

Importante

Todo dia às 18hrs estou subindo o código das aulas do dia corrente em classes. Se você for iniciar o projeto, remova a pasta classes para iniciar do zero!

Running

Execute npm ci na pasta que contém o arquivo package.json para restaurar os pacotes
Execute npm start e em seguida vá para o seu navegador em http://localhost:3000 para visualizar a página acima

Checklist Features

Video Uploader
- [] - Deve entender videos em formato MP4 mesmo se não estiverem fragmentados
- [] - Deve processar itens em threads isoladas com Web Workers
- [] - Deve converter fragmentos de videos em formato 144p
- [] - Deve renderizar frames em tempo real em elemento canvas
- [] - Deve gerar arquivos WebM a partir de fragmentos

Desafios

[] - Encodar em 360p e 720p
[] - Fazer encoding/decoding track de áudio
[] - Fazer também upload de track de áudio
[] - Concatenar o arquivo final no servidor em um arquivo só
[] - Corrigir problema do Webm de não mostrar a duração do video
[] - Corrigir a responsividade do site
[] - Tentar usar outros muxers
- https://github.com/Vanilagy/webm-muxer
- https://github.com/Vanilagy/mp4-muxer

Links mostrados nos aulas:

Reuni todos os links em referências

Considerações

Tire suas dúvidas sobre os desafios em nossa comunidade, o objetivo é você aprender de forma divertida. Surgiu dúvidas? Pergunte por lá!
Ao completar qualquer um dos desafios, envie no canal #desafios da comunidade no Discord

FAQ

browser-sync está lançando erros no Windows e nunca inicializa:
- Solução: Trocar o browser-sync pelo http-server.
  1. instale o http-server com npm i -D http-server
  2. no package.json apague todo o comando do browser-sync e substitua por npx http-server .
  3. agora o projeto vai estar executando na :8080 então vá no navegador e tente acessar o http://localhost:8080/ A unica coisa, é que o projeto não vai reiniciar quando voce alterar algum código, vai precisar dar um F5 na página toda vez que alterar algo

DevCaress/guia-entrevistas-de-programacion

2023-10-26T01:30:08Z

Recursos

Recursos varios para prepararte para una entrevista técnica

Índice

Buenas practicas

Clean architecture

Buenas practicas en:

Javascript

Guidelines for writing JavaScript code examples

JavaScript Best Practices by W3.org

JavaScript Best Practices by W3Schools

Airbnb JavaScript Style Guide()

30 JavaScript Best Practices for Beginners

Vue.js

12 VueJS Best Practices

Vue Patterns

React.js

10 Best Practices for Writing Clean React Code

React Best Practices – Tips for Writing Better React Code in 2022

React best practices and patterns to reduce code

React Best Practices Every Developer Have to Follow in 2023

Angular

10 Best Practices for Building Scalable Angular Applications — With examples

https://www.tatvasoft.com/blog/angular-optimization-and-best-practices/

Angular coding style guide

Typescript

TypeScript best practices by AWS

TypeScript Best Practices 2021

Python

Code Style in Python

Python Best Practices to Follow in 2023

dJango

dJango best practices 2022

Django Model Best Practices: Tips and Tricks for Clean and Efficient Code

Dart

Effective Dart: Design

Flutter

Flutter Best Practices

The Dart Way: Best Coding Practices

10 Best Practices Every Flutter Developer Should Follow

Java

Java Best Practices (recomendado)

Java Best Practices

10 best practices in Java

C++

Collecting the best C++ practices

Boost Your C++ Coding Skills: 5 Tips For Faster, Better Code

PHP

PHP Programming Best Practices and Coding Styles

PHP Best Practices

Algoritmos y estructuras de datos

Estructuras de datos

Stack
Queue
Types of Queue
Circular Queue
Priority Queue
Deque
Linked List
Linked List Operations
Types of Linked List
Hash Table
Heap Data Structure
Fibonacci Heap
Decrease Key and Delete node from Fibonacci Heap
Tree Data Structure
Tree Traversal
Binary Tree
Full Binary Tree
Perfect Binary Tree
Complete Binary Tree
Balanced Binary Tree
Binary Search Tree
AVL Tree
B Tree
Insertion into B-tree
Deletion from B-tree
B+ Tree
Insertion on a B+ Tree
Deletion from a B+ Tree
Red Black Tree
Insertion in Red Black Tree
Deletion from Red Black Tree
Graph Data Structure
Spanning Tree
Strongly Connected Components
Adjacency Matrix
Adjacency List
DFS Algorithm
Breadth-first Search
Bellman Ford's Algorithm

Visualizar algoritmos

Visualgo

En esta web podrás ver como funcionan de manera visual los siguientes algoritmos:

Sorting
- Bubble Sort
- Selection Sort
- Insertion Sort
- Merge Sort
- Quick Sort
- Random Quick Sort
- Counting Sort
- Radix Sort
Linked List
- Stack
- Queue
- Doubly Linked List
- Deque
Hash Tables
- Linear Probing
- Quadratic Probing
- Double Hashing
- Separate Chaining
Binary Heap
Binary Search Tree
- AVL Tree

Patrones de diseño

Patrones de diseño Español (Recomendación personal)

Patrones de diseño en Javascript

Patrones Creacionales
- Singleton
- Factory Method
- Abstract Factory
- Builder
- Prototype
Patrones Estructurales
- Adapter
- Bridge
- Composite
- Decorator
- Facade
- Flyweight
- Proxy
Patrones de comportamiento
- Chain of Responsibility
- Command
- Iterator
- Mediator
- Memento
- Observer
- State
- Strategy
- Template Method
- Interpreter
- Visitor

Practicar algoritmos y estructuras de datos

Preguntas más frecuentes

Ejercicios más comunes en entrevistas

Invertir un array/string
Eliminar duplicados de un array/string

Preguntas más comunes de Javascript

Qué es el Event Loop??
- Visualizar Event Loop
- Ejemplos para entender Event Loop

Temas

VUEJS

Worked with viewer version 2 second version (NOX framework)

Composition API- what kind of things u use- (own hooks,ref methods,

Typescript integration have u find it difficult- working with JS or typescript in vuejs-

Mutation action and so on (explain)

Blogic

Environment and ecosystem

Jenkins pipeline

Azure AWS- file management system S3 buckets-

Share keys

Master passwords

Designing principles

Predefine Es-lint. Code readable

Improve the code- layer of abstraction, Automation test, unit testing, end to end testing

Define release flow GIT –

- Coding task**

find ids count in object

customer comunication

Waterfall, agile, cascade methodologies

calculate the complexity of a ticket or user story.

estimate in relative units.

Dif using points and hours

Designing architecture

Object oriented programming

paradigm & others (functional programming i.e…..)

Base paradigm principals (object oriented)

WHAT ARE THE BEST PRACTICES THAT U APPLY IN YOUR PROJECT

Data bases

Have u work with databases? Sql

Do u know some techniques of optimization (normalize my table, my information from many to many so I don’t have to look up for every single email, primary keys, (index information)limited 10,000 thousand records, no doing a query with 2 base connection, joing, inner join reck heads? To find specific pattern that brings all your requirements.

Dif sql and non sql data bases

SOFTWARE CONSTRUCTION QUESTIONS

Make the answer short for this questions until we star with framework

Styling- CSSS, Flybox lay out, Dif btw flexbox and green lay out, complex conditions in CSS, Qerys

create the naming of the CSS

dif frameworks for CSS

CSS defining variables

Create theme for CSS

HTML

Semantic mark up

accessibility

DOM in HTML

Shadow dom

Graphics

optimize an HTML page

data visualization tools, D3 high charts,

Map box.

PROGRAMING LANGUAJES

hosting

type variables in JS- array

promise and asynchrony way-

multithread or single thread

manage more than one thread

HTTP works

AJAX

Graphql- how it works

Progressive web app

Configure some boundless

deal with troubles in production

AWS- optimize services

Code quality – unit testing tools

analysis tools for the code- solarq

metrics unit testing-

GIT

Garbage collector

Compare HTTP request and web sockets.

Cloud (ur experience and questions according to)

Software development process

Life cycles (what is it? How it works with it)

Kanban and scrum

Engineer based on previous exp risk. What tools to measure risk.

Requirements functional and non-functional

Optional, mostly for PM managers good to understand. RCA metrics

RACI es un acrónimo en inglés (Responsable, Accountable, Consulted, Informed) que ayuda a los equipos a brindar

claridad con respecto a la asignación de roles en un proyecto y determinar quién es el responsable de una tarea específica

Integration testing

Code quality

solid principles

dif btw class and object

encapsulation

architecture patterns i.e. MVC

how microservices work

bootstrap and Semantic elements in HTML

Java -Single treat or Multithreaded

Asynchronies task-JavaScript

promises

promise all.

promise rest.

End to end testing

Functional and non functional (how much time should tell per request, browser supports- non functional)

RACI MATRIX – root cause analysis-

Used case diagram

Software architecture/techniques

JavaScript-object oriented programing- explain some crucial parts of object oriented-

Caring techniques

SOLID principles,

Data bases-

What database u have been working with

Using sequel have u done like huge migration, which tools have u use

injecting

Mongo DB (dynamo DB)

CSS framework

Script or Flex

sass lass advantages u see on regular CSS

Variables is there any way to declare a variable in the normal CSS

Mixings- maybe something else u have found helpful from pre processors

Nesting deviarables

Unit since CSS

Difference btwn RAM and pixels

Difference btw Fixet & absolut

Set collection / what is it

What about net collection

Week map and week set map collection

Garbage collector

Proxy API- it has a crucial role in nodejs framework track observability and

reflect API.

Asynchronous this flow

Event loop

Web API

Call stack

How the event knows this piece of code is ready to execute?-

Macro cube

JavaScript

The commands from JavaScript or is browser related

Storages-

HTTP

Dif local storage & session storage

Networking

HTTP difference HTPS

How HTTPS works in plain English- how the protocol works

REST concept

GraphQl

Vuejs, excel library-

In oksys have u implement such things /interceptor

Authors

@devcaress

shuttlenetwork/shuttle

2023-10-26T01:30:08Z

Experience the global internet using Shuttle, the swiftest and most uncluttered proxy solution. Relish a heightened level of privacy during your online sessions, free from censorship.

100 stars and 600 forks for v3 release

pablosanjose/Quantica.jl

2023-10-25T01:33:55Z

Simulation of quantum systems on a lattice

JuliaTrustworthyAI/ConformalPrediction.jl

2023-10-26T01:30:45Z

Predictive Uncertainty Quantification through Conformal Prediction for Machine Learning models trained in MLJ.

RamiKrispin/lang2sql

2023-10-26T01:30:46Z

Language to SQL Translator

lang2sql

🚧WIP 🏗️, pre spell checking🛠️

A guide for building a language to SQL translator with LLM. Working on the code now 🤓 full documentation should come in the next few weeks 😎.

google/secrets-gradle-plugin

2023-10-25T01:34:31Z

A Gradle plugin for providing your secrets to your Android project.

Secrets Gradle Plugin for Android

A Gradle plugin for providing your secrets securely to your Android project.

This Gradle plugin reads secrets from a properties file not checked into version control, such as local.properties, and expose those properties as variables in the Gradle-generated BuildConfig class and in the Android manifest file.

DISCLAIMER: This plugin is primarily for hiding your keys from version control. Since your key is part of the static binary, your API keys are still recoverable by decompiling an APK. So, securing your key using other measures like adding restrictions (if possible) are recommended.

Requirements

Gradle-based Android project
Android Gradle plugin 7.0.2

Installation

NOTE: Starting from v1.1.0, the plugin ID was changed to "com.google.android.libraries.mapsplatform.secrets-gradle-plugin" and the plugin is now being distributed via Google Maven (gMaven). You can still download previous versions of the plugin from Gradle's plugin portal, but new versions will now only be distributed through gMaven.

In your project's root build.gradle file:

Groovy:

buildscript {
    dependencies {
        classpath "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:2.0.1"
    }
}

Kotlin:

buildscript {
    dependencies {
        classpath("com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:2.0.1")
    }
}

In your app-level build.gradle file:

Groovy:

plugins {
    id 'com.google.android.libraries.mapsplatform.secrets-gradle-plugin'
}

Kotlin:

plugins {
    id("com.google.android.libraries.mapsplatform.secrets-gradle-plugin")
}

This plugin also supports library module type (com.android.library). Just install the plugin in your library-level build.gradle file and keys will be visible inside that module as well.

Snapshot Releases

Snapshot releases, which are distributed via GitHub Packages, are also available for latest fixes. To use a snapshot release, add the following repository to your project-level build.gradle file:

Groovy:

buildscript {
    repositories {
        maven {
            url = uri("https://maven.pkg.github.com/google/secrets-gradle-plugin")
            credentials {
                username = project.findProperty("GITHUB_USER") ?: System.getenv("GITHUB_USER")
                password = project.findProperty("GITHUB_TOKEN") ?: System.getenv("GITHUB_TOKEN")
            }
        }
    }
    dependencies {
        classpath "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:<version>-SNAPSHOT"
    }
}

Also, see Authenticating to GitHub Packages.

Example Usage

Example contents of local.properties under your root project:

apiKey=YOUR_API_KEY

After applying the plugin and building your project, the API key then becomes accessible in two ways.

As a BuildConfig value:

val apiKey = BuildConfig.apiKey

As a variable accessible in your AndroidManifest.xml file:

<meta-data android:value="${apiKey}" />

CI/CD Systems

For CI/CD systems, consider creating and checking in version control a default properties file with all the same keys required by your app but with safe default values. To do this, create a properties file and set the defaultPropertiesFileName value to that file name. For example:

secrets {
    defaultPropertiesFileName = 'local.defaults.properties'
}

Configuration Options

The plugin can optionally be configured:

secrets {
    // Change the properties file from the default "local.properties" in your root project
    // to another properties file in your root project.
    propertiesFileName 'secrets.properties'

    // A properties file containing default secret values. This file can be checked in version
    // control.
    defaultPropertiesFileName = 'secrets.defaults.properties'

    // Configure which keys should be ignored by the plugin by providing regular expressions.
    // "sdk.dir" is ignored by default.
    ignoreList.add("keyToIgnore") // Ignore the key "keyToIgnore"
    ignoreList.add("sdk.*")       // Ignore all keys matching the regexp "sdk.*"
}

Build-Variant Specific Properties

To set build-variant specific properties (build type or flavor), create a properties file at the root directory of the project with the same name as the variant. For example, to set keys specific for the release build type, create a new file called release.properties containing release-specific keys.

Contributing

Contributions to this library are always welcome and highly encouraged!

See CONTRIBUTING.md and CODE_OF_CONDUCT.md for more information on how to get started.

License

Apache 2.0. See LICENSE for more information.

msasikanth/twine

2023-10-25T01:34:31Z

Anilist client based on Saikou

Dantotsu (🚧 ALPHA 🚧)

⚠️ WARNING: This project is in alpha stage. Things may not work as expected.

Dantotsu is crafted from the ashes of Saikou and based on simplistic yet state-of-the-art elegance. It is an Anilist only client, which also lets you stream-download Anime & Manga through extensions.

Dantotsu (断トツ; Dan-totsu) literally means the best of the best in Japanese. Well, we would like to say this is the best open source app for anime and manga on Android, but hey, try it out yourself & judge!

🌟STAR THIS REPOSITORY TO SUPPORT THE DEVELOPER AND ENCOURAGE THE DEVELOPMENT OF THE APPLICATION!

Warning

Please do not attempt to upload Dantotsu or any of it's forks on Playstore or any other Android appstores on the internet. Doing so, may infringe their terms and conditions. This may result to legal action or immediate take-down of the app.

Extension Status

Type	Status
Anime Extensions	Working
Manga Extensions	"Working"
Light Novel Extensions	Not Working

APP FEATURES

Easy and functional way to both, watch anime and read manga, ad-free.
A completely open source app with a nice UI & Animations :)
Aniyomi extension support built right into the app.
Synchronize anime and manga real-time with AniList and MyAnimeList. Easily categorise anime and manga based on your current status. (Powered by AniList)
Find all shows using thoroughly and frequently updated list of all trending, popular and ongoing anime based on scores.
View extensive details about anime shows, movies and manga titles. It also features ability to countdown to the next episode of airing anime. (Powered by AniList & MyAnimeList)
Get notified when new episodes/chapters are released!

Available Anime sources:- NONE BUILT IN! add your own extensions in the settings menu (Dantotsu has no affiliation with any of the extensions)
Available Manga sources:- NONE BUILT IN! add your own extensions in the settings menu (Dantotsu has no affiliation with any of the extensions)

Planned Stuff

get app out of alpha
Accent Color Change (RIP Hot Pink Supremacy.)

Rejected Stuff (still rejected)

Sources of any language except English
News Section in the App
Comment Section

WANT TO CONTRIBUTE?

All contributions are welcome, from code to documentation to graphics to design suggestions to bug reports. Please use GitHub to its fullest; contribute Pull Requests, contribute tutorials or other content- whatever you have to offer, we can use it!
You can come hang out with our awesome community and request new features and report any bugs or issue at our discord server too.

Official Discord Server

VISIT FOR MORE INFORMATION:-

no website yet :(

DISCLAIMER

Dantotsu by itself only provides an anime and manga tracker and does not provide any anime or manga streaming or downloading capabilities.
Dantotsu or any of its developer/staff don't host any of the content found inside Dantotsu. Any and all images and anime/manga information found in the app are taken from various public APIs (AniList, MyAnimeList, Kitsu).
Furthermore, all of the anime/manga links found in Dantotsu are taken from various 3rd party plugins and have no affiliation with Dantotsu or its staff.
Dantotsu or it's owners aren't liable for any misuse of any of the contents found inside or outside of the app and cannot be held accountable for the distribution of any of the contents found inside the app.
By using Dantotsu, you comply to the fact that the developer of the app is not responsible for any of the contents found in the app. You also agree to the fact that you may not use Dantotsu to download or stream any copyrighted content.
If the internet infringement issues are involved, please contact the source website. The developer does not assume any legal responsibility.

License

Dantotsu is licensed under the GNU General Public License v3.0

netz39/www.netz39.de

2023-10-25T01:34:54Z

Webseite des Netz39 e.V.

acsu123/HOHO_H

2023-10-25T01:35:08Z

nothing_is_here

HOHO_H

nothing_is_here

swxy/NoPixel-2-Full-Server

2023-10-25T01:35:08Z

nopickles

Swxy#0001 Sydres#9887 Rubidium#7756(hawkeye) Full Nopixel Files from 2.0

NoPixel Launchers Source: https://github.com/swxy/nopixelaunchersource

Preview of the server : https://www.youtube.com/watch?v=TV4m8urqEus&t

SQL : https://mega.nz/file/iZtiUZ4b#ru1JOCeFhitJsMAvfSMl1PCTHLZEsGG_l2qixP3PjzQ

Enjoy Swxy#0001 :)

Installation

Create a FiveM server (guide)
Stop the server
Open the new folder that was created under the txData folder
Delete everything in that folder
Clone this repository to that folder
Run nopixel.sql in your database
Run set-passwords.bat (requires wlr - I used Ubuntu)
Start the server

echasnovski/mini.hipatterns

2023-10-25T01:35:08Z

Highlight patterns in text. Part of 'mini.nvim' library.

Highlight patterns in text

See more details in Features and help file.

⦿ This is a part of mini.nvim library. Please use this link if you want to mention this module.

⦿ All contributions (issues, pull requests, discussions, etc.) are done inside of 'mini.nvim'.

⦿ See the repository page to learn about common design principles and configuration recipes.

If you want to help this project grow but don't know where to start, check out contributing guides of 'mini.nvim' or leave a Github star for 'mini.nvim' project and/or any its standalone Git repositories.

Demo

https://github.com/echasnovski/mini.nvim/assets/24854248/130374e2-4e6c-43cf-af33-43d816b4fa32

Features

Highlight text with configurable patterns and highlight groups (can be string or callable).
Highlighting is updated asynchronously with configurable debounce delay.
Function to get matches in a buffer.

See *MiniHipatterns-examples* tag in help page for examples of common use cases.

Notes:

It does not define any highlighters by default. Add to config.highlighters to have a visible effect.

Example usage

local hipatterns = require('mini.hipatterns')
hipatterns.setup({
  highlighters = {
    -- Highlight standalone 'FIXME', 'HACK', 'TODO', 'NOTE'
    fixme = { pattern = '%f[%w]()FIXME()%f[%W]', group = 'MiniHipatternsFixme' },
    hack  = { pattern = '%f[%w]()HACK()%f[%W]',  group = 'MiniHipatternsHack'  },
    todo  = { pattern = '%f[%w]()TODO()%f[%W]',  group = 'MiniHipatternsTodo'  },
    note  = { pattern = '%f[%w]()NOTE()%f[%W]',  group = 'MiniHipatternsNote'  },

    -- Highlight hex color strings (`#rrggbb`) using that color
    hex_color = hipatterns.gen_highlighter.hex_color(),
  },
})

Installation

This plugin can be installed as part of 'mini.nvim' library (recommended) or as a standalone Git repository.

There are two branches to install from:

main (default, recommended) will have latest development version of plugin. All changes since last stable release should be perceived as being in beta testing phase (meaning they already passed alpha-testing and are moderately settled).
stable will be updated only upon releases with code tested during public beta-testing phase in main branch.

Here are code snippets for some common installation methods (use only one):

With folke/lazy.nvim

Github repo	Branch	Code snippet
'mini.nvim' library	Main	`{ 'echasnovski/mini.nvim', version = false },`
Stable	`{ 'echasnovski/mini.nvim', version = '*' },`
Standalone plugin	Main	`{ 'echasnovski/mini.hipatterns', version = false },`
Stable	`{ 'echasnovski/mini.hipatterns', version = '*' },`

With wbthomason/packer.nvim

Github repo	Branch	Code snippet
'mini.nvim' library	Main	`use 'echasnovski/mini.nvim'`
Stable	`use { 'echasnovski/mini.nvim', branch = 'stable' }`
Standalone plugin	Main	`use 'echasnovski/mini.hipatterns'`
Stable	`use { 'echasnovski/mini.hipatterns', branch = 'stable' }`

With junegunn/vim-plug

Github repo	Branch	Code snippet
'mini.nvim' library	Main	`Plug 'echasnovski/mini.nvim'`
Stable	`Plug 'echasnovski/mini.nvim', { 'branch': 'stable' }`
Standalone plugin	Main	`Plug 'echasnovski/mini.hipatterns'`
Stable	`Plug 'echasnovski/mini.hipatterns', { 'branch': 'stable' }`

Important: don't forget to call require('mini.hipatterns').setup() with non-empty highlighters to auto-enable highlighting in all normal buffers.

Note: if you are on Windows, there might be problems with too long file paths (like error: unable to create file <some file name>: Filename too long). Try doing one of the following:

Enable corresponding git global config value: git config --system core.longpaths true. Then try to reinstall.
Install plugin in other place with shorter path.

Default config

-- No need to copy this inside `setup()`. Will be used automatically.
{
  -- Table with highlighters (see |MiniHipatterns.config| for more details).
  -- Nothing is defined by default. Add manually for visible effect.
  highlighters = {},

  -- Delays (in ms) defining asynchronous highlighting process
  delay = {
    -- How much to wait for update after every text change
    text_change = 200,

    -- How much to wait for update after window scroll
    scroll = 50,
  },

}

Similar plugins

upbound/configuration-aws-database

2023-10-26T01:32:03Z

AWS Database Configuration

haggi/OpenMaya

2023-10-25T01:35:46Z

Maya to renderer connections

Ferddi/pbnet-monkey

2023-10-25T01:36:09Z

PushButton Networking for Monkey

aggregion/helm-charts-cdp

2023-10-25T01:36:26Z

Helm Charts for Aggregion CDP

interledger/helm-charts

2023-10-25T01:36:26Z

Interledger Kubernetes Helm Charts

georgyo/avalon

2023-10-25T01:36:54Z

andgineer/TRegExpr

2023-10-25T01:38:06Z

A conceptual Delphi IDE plugin - to visualize the uses section

trlinkin/puppet-nsswitch

2023-10-25T01:39:17Z

Puppet module to control /etc/nsswitch.conf file.

huggingface/datasets

2023-10-25T01:39:24Z

🤗 The largest hub of ready-to-use datasets for ML models with fast, easy-to-use and efficient data manipulation tools

🤗 Datasets is a lightweight library providing two main features:

one-line dataloaders for many public datasets: one-liners to download and pre-process any of the major public datasets (image datasets, audio datasets, text datasets in 467 languages and dialects, etc.) provided on the HuggingFace Datasets Hub. With a simple command like squad_dataset = load_dataset("squad"), get any of these datasets ready to use in a dataloader for training/evaluating a ML model (Numpy/Pandas/PyTorch/TensorFlow/JAX),
efficient data pre-processing: simple, fast and reproducible data pre-processing for the public datasets as well as your own local datasets in CSV, JSON, text, PNG, JPEG, WAV, MP3, Parquet, etc. With simple commands like processed_dataset = dataset.map(process_example), efficiently prepare the dataset for inspection and ML model evaluation and training.

🎓 Documentation 🔎 Find a dataset in the Hub 🌟 Share a dataset on the Hub

🤗 Datasets is designed to let the community easily add and share new datasets.

🤗 Datasets has many additional interesting features:

Thrive on large datasets: 🤗 Datasets naturally frees the user from RAM memory limitation, all datasets are memory-mapped using an efficient zero-serialization cost backend (Apache Arrow).
Smart caching: never wait for your data to process several times.
Lightweight and fast with a transparent and pythonic API (multi-processing/caching/memory-mapping).
Built-in interoperability with NumPy, pandas, PyTorch, TensorFlow 2 and JAX.
Native support for audio and image data.
Enable streaming mode to save disk space and start iterating over the dataset immediately.

🤗 Datasets originated from a fork of the awesome TensorFlow Datasets and the HuggingFace team want to deeply thank the TensorFlow Datasets team for building this amazing library. More details on the differences between 🤗 Datasets and tfds can be found in the section Main differences between 🤗 Datasets and tfds.

Installation

With pip

🤗 Datasets can be installed from PyPi and has to be installed in a virtual environment (venv or conda for instance)

pip install datasets

With conda

🤗 Datasets can be installed using conda as follows:

conda install -c huggingface -c conda-forge datasets

Follow the installation pages of TensorFlow and PyTorch to see how to install them with conda.

For more details on installation, check the installation page in the documentation: https://huggingface.co/docs/datasets/installation

Installation to use with PyTorch/TensorFlow/pandas

If you plan to use 🤗 Datasets with PyTorch (1.0+), TensorFlow (2.2+) or pandas, you should also install PyTorch, TensorFlow or pandas.

For more details on using the library with NumPy, pandas, PyTorch or TensorFlow, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart

Usage

🤗 Datasets is made to be very simple to use - the API is centered around a single function, datasets.load_dataset(dataset_name, **kwargs), that instantiates a dataset.

This library can be used for text/image/audio/etc. datasets. Here is an example to load a text dataset:

Here is a quick example:

from datasets import load_dataset

# Print all the available datasets
from huggingface_hub import list_datasets
print([dataset.id for dataset in list_datasets()])

# Load a dataset and print the first example in the training set
squad_dataset = load_dataset('squad')
print(squad_dataset['train'][0])

# Process the dataset - add a column with the length of the context texts
dataset_with_length = squad_dataset.map(lambda x: {"length": len(x["context"])})

# Process the dataset - tokenize the context texts (using a tokenizer from the 🤗 Transformers library)
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained('bert-base-cased')

tokenized_dataset = squad_dataset.map(lambda x: tokenizer(x['context']), batched=True)

If your dataset is bigger than your disk or if you don't want to wait to download the data, you can use streaming:

# If you want to use the dataset immediately and efficiently stream the data as you iterate over the dataset
image_dataset = load_dataset('cifar100', streaming=True)
for example in image_dataset["train"]:
    break

For more details on using the library, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart and the specific pages on:

Loading a dataset: https://huggingface.co/docs/datasets/loading
What's in a Dataset: https://huggingface.co/docs/datasets/access
Processing data with 🤗 Datasets: https://huggingface.co/docs/datasets/process
- Processing audio data: https://huggingface.co/docs/datasets/audio_process
- Processing image data: https://huggingface.co/docs/datasets/image_process
- Processing text data: https://huggingface.co/docs/datasets/nlp_process
Streaming a dataset: https://huggingface.co/docs/datasets/stream
Writing your own dataset loading script: https://huggingface.co/docs/datasets/dataset_script
etc.

Add a new dataset to the Hub

We have a very detailed step-by-step guide to add a new dataset to the datasets already provided on the HuggingFace Datasets Hub.

You can find:

Main differences between 🤗 Datasets and `tfds`

If you are familiar with the great TensorFlow Datasets, here are the main differences between 🤗 Datasets and tfds:

the scripts in 🤗 Datasets are not provided within the library but are queried, downloaded/cached and dynamically loaded upon request
the backend serialization of 🤗 Datasets is based on Apache Arrow instead of TF Records and leverage python dataclasses for info and features with some diverging features (we mostly don't do encoding and store the raw data as much as possible in the backend serialization cache).
the user-facing dataset object of 🤗 Datasets is not a tf.data.Dataset but a built-in framework-agnostic dataset class with methods inspired by what we like in tf.data (like a map() method). It basically wraps a memory-mapped Arrow table cache.

Disclaimers

🤗 Datasets may run Python code defined by the dataset authors to parse certain data formats or structures. For security reasons, we ask users to:

check the dataset scripts they're going to run beforehand and
pin the revision of the repositories they use.

If you're a dataset owner and wish to update any part of it (description, citation, license, etc.), or do not want your dataset to be included in the Hugging Face Hub, please get in touch by opening a discussion or a pull request in the Community tab of the dataset page. Thanks for your contribution to the ML community!

BibTeX

If you want to cite our 🤗 Datasets library, you can use our paper:

@inproceedings{lhoest-etal-2021-datasets,
    title = "Datasets: A Community Library for Natural Language Processing",
    author = "Lhoest, Quentin  and
      Villanova del Moral, Albert  and
      Jernite, Yacine  and
      Thakur, Abhishek  and
      von Platen, Patrick  and
      Patil, Suraj  and
      Chaumond, Julien  and
      Drame, Mariama  and
      Plu, Julien  and
      Tunstall, Lewis  and
      Davison, Joe  and
      {\v{S}}a{\v{s}}ko, Mario  and
      Chhablani, Gunjan  and
      Malik, Bhavitvya  and
      Brandeis, Simon  and
      Le Scao, Teven  and
      Sanh, Victor  and
      Xu, Canwen  and
      Patry, Nicolas  and
      McMillan-Major, Angelina  and
      Schmid, Philipp  and
      Gugger, Sylvain  and
      Delangue, Cl{\'e}ment  and
      Matussi{\`e}re, Th{\'e}o  and
      Debut, Lysandre  and
      Bekman, Stas  and
      Cistac, Pierric  and
      Goehringer, Thibault  and
      Mustar, Victor  and
      Lagunas, Fran{\c{c}}ois  and
      Rush, Alexander  and
      Wolf, Thomas",
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing: System Demonstrations",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-demo.21",
    pages = "175--184",
    abstract = "The scale, variety, and quantity of publicly-available NLP datasets has grown rapidly as researchers propose new tasks, larger models, and novel benchmarks. Datasets is a community library for contemporary NLP designed to support this ecosystem. Datasets aims to standardize end-user interfaces, versioning, and documentation, while providing a lightweight front-end that behaves similarly for small datasets as for internet-scale corpora. The design of the library incorporates a distributed, community-driven approach to adding datasets and documenting usage. After a year of development, the library now includes more than 650 unique datasets, has more than 250 contributors, and has helped support a variety of novel cross-dataset research projects and shared tasks. The library is available at https://github.com/huggingface/datasets.",
    eprint={2109.02846},
    archivePrefix={arXiv},
    primaryClass={cs.CL},
}

If you need to cite a specific version of our 🤗 Datasets library for reproducibility, you can use the corresponding version Zenodo DOI from this list.

THUDM/AgentTuning

2023-10-25T01:39:24Z

AgentTuning: Enabling Generalized Agent Abilities for LLMs

AgentTuning: Enabling Generalized Agent Abilities For LLMs

🤗 Model (AgentLM-70B) • 🤗 Dataset (AgentInstruct) • 📃 Paper • 🌐 Project Page

中文版(Chinese)

AgentTuning represents the very first attempt to instruction-tune LLMs using interaction trajectories across multiple agent tasks. Evaluation results indicate that AgentTuning enables the agent capabilities of LLMs with robust generalization on unseen agent tasks while remaining good on general language abilities. We have open-sourced the AgentInstruct dataset and AgentLM.

Main Result

Figure 1 Overall score in our held-in and held-out tasks

AgentInstruct

AgentInstruct is a meticulously curated dataset featuring 1,866 high-quality interactions, designed to enhance AI agents across 6 diverse real-world tasks.

🔍 CoT - Harness the power of ReAct, offering detailed thought explanations for each action, ensuring an intricate understanding of the model's decision-making journey.
🌍 Diversity - Spanning 6 real-world scenarios, from Daily Household Routines to Database Operations, and their average turns range from 5 to 35.
🎯 Precision - Not all trajectories of GPT-4 are effective! Ours are rigorously filtered using strict rewards to ensure top-notch quality.
✅ Assurance - Rigorous checks to avoid data leakage, ensuring pristine dataset quality.

AgentInstruct dataset is available on 🤗Huggingface Repo.

AgentLM

AgentLM models are produced by mixed training on AgentInstruct dataset and ShareGPT dataset from Llama2-chat series.

The models follow the conversation format of Llama-2-chat, with system prompt fixed as You are a helpful, respectful and honest assistant.

The 7B, 13B, and 70B models are available on Huggingface model hub.

Model	Huggingface Repo
AgentLM-7B	🤗Huggingface Repo
AgentLM-13B	🤗Huggingface Repo
AgentLM-70B	🤗Huggingface Repo

Run AgentLM

We use Text-Generation-Inference to accelerate the evaluation process.

You can start a AgentLM-70b instance with:

cd docker
docker compose -f agentlm-70b.yml up

Upon successful execution, a client will be available on port 30070. Here an example of launching a request:

curl 127.0.0.1:30070/generate \
    -X POST \
    -H 'Content-Type: application/json' \
    -d '{"inputs": "[INST] <<SYS>>\nYou are a helpful, respectful and honest assistant.\n<</SYS>>\n\nHello! [/INST]", "parameters":{"temperature": 1.0}}'

# {"generated_text":"Hello! How can I help you today? "}

You may replicate the services in docker compose file to multiple inference instance if more GPUs are available.

Evaluation

Here are details of our evaluation task, including 6 held-in tasks and 6 held-out tasks.

Held-in Tasks

The 6 held-in tasks are selected from AgentBench. However, since AgentBench is still under active development, the results from the latest branch might not fully reproduce the results reported in the paper. The evaluation code of this project is located in ./AgentBench.old.

Held-out Tasks

Held-out tasks are recompiled from the following frameworks:

Task	AgentTuning Setup	Original Repo
SciWorld	📂 eval_heldout/science-world	💻 allenai/ScienceWorld
MiniWoB++	📂 eval_heldout/miniwob++	💻 Farama-Foundation/miniwob-plusplus
HotpotQA	📂 eval_heldout/hotpotQA	💻 salesforce/BOLAA
ReWOO	📂 eval_heldout/rewoo	💻 billxbf/ReWOO
WebArena	📂 eval_heldout/webarena	💻 web-arena-x/webarena
Digital Card Game	💻 AgentBench.old ( Extend Split )	💻 THUDM/AgentBench

General Tasks

MMLU Setup:

Download the 14k multi-choice questions into ./data:

cd data
wget https://people.eecs.berkeley.edu/~hendrycks/data.tar
tar xf data.tar
cd ..

Evaluate Hf model(organization/name or ckpt path)by executing the evaluation script:
```
python eval_general/evaluate_mmlu_hf.py -c THUDM/AgentLM-70b
```

GSM8k Setup:

Start TGI worker
Run the evaluation
```
python eval_general/evaluate_gsm8k_tgi.py --port 30070
```
Use --sample-input-file to load a local dataset, or GSM8K will be loaded for evaluation.

MT-Bench Setup:

Install FastChat locally

git clone https://github.com/lm-sys/FastChat.git
pip install -e FastChat

Start TGI worker

Run the evaluation script:

python eval_general/eval_mt_bench_tgi.py --host 127.0.0.1 --port 30070 --model-id agentlm-70b

Evaluate the answers with GPT-4

cd FastChat/fastchat/llm_judge
OPENAI_API_KEY=<your-api-key> python gen_judgment.py --model-list agentlm-70b --parallel <number-of-cuncurrent-requests>

Citation

If you find our work useful, please consider citing AgentTuning:

@misc{zeng2023agenttuning,
      title={AgentTuning: Enabling Generalized Agent Abilities for LLMs},
      author={Aohan Zeng and Mingdao Liu and Rui Lu and Bowen Wang and Xiao Liu and Yuxiao Dong and Jie Tang},
      year={2023},
      eprint={2310.12823},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}

rupeshs/fastsdcpu

2023-10-25T01:39:24Z

Fast stable diffusion on CPU

FastSD CPU ✨

Faster version of stable diffusion running on CPU.

Took 10 seconds to generate single 512x512 image on Core i7-12700(With OpenVINO).

Based on Latent Consistency Models .

Features

Supports 256,512,768 image sizes
Supports Windows and Linux
Saves images
Settings to control,steps,guidance and seed
Added safety checker setting
Maximum inference steps increased to 25
OpenVINO support

OpenVINO support

Thanks deinferno for the OpenVINO model contribution. Currently, it is tested on Windows only,by default it is disabled. We found a 50% speed improvement using OpenVINO.It Took 10 seconds to generate single 512x512 image on Core i7-12700

LCM Models

Currently LCM model(Dreamshaper_v7) is supported (Diffuser format).

FastSD CPU on Windows

❗You must have a working Python installation.(Recommended : Python 3.10 or 3.11 )

Clone/download this repo or download release.

Installation

Double click install.bat (It will take some time to install,depends on your internet speed.)

Run

To start fastsdcpu double click start.bat

FastSD CPU on Linux

Ensure that you have Python 3.8 or higher version installed.

Clone/download this repo
In the terminal enter into fastsdcpu directory
Run the following command

chmod +x install.sh

./install.sh
To start FastSD CPU run

chmod +x start.sh

./start.sh

editpa/Colas

2023-10-25T01:39:46Z

Colas en R

Colas

Colas en R

haneuljangkr/bayaka-subsistence-networks

2023-10-25T01:39:46Z

Women’s subsistence networks scaffold cultural transmission among BaYaka foragers in the Congo Basin

Requirements for analyses:

R: https://cran.r-project.org
STRAND: https://github.com/ctross/STRAND
cmdstanr: https://mc-stan.org/cmdstanr/

Packages used for data processing and visualisation:

Rethinking: https://xcelab.net/rm/statistical-rethinking/
tidyverse: https://www.tidyverse.org

Details

To reproduce the results presented in the manuscript, please first go into the 'code/' folder of the repository. It would probably be best to review the many different scripts for data processing, analysis and visualisation. Then, if you would like to reproduce the results reported in the publication, call the run all file that can be found in the repository:

source("./run_all.R")

Alternatively, you can go into each processing/analysis/visualisation script and run them separately.

Data file

The strand object data (PublicVersion.RData) contains all data used to run models, including dayID, focalID, ind1, ind2, observed together (1: observed being together in a focal woman's foraging group at the day of day ID, 0: not observed in a focal woman's foraging group), camp_together (1: being at camp together at the day of dayID (cohabitants), 0: not being at camp together), gender difference (female-female, different gender, male-male), co-residence (0: not living together in the same household or 1: co-residing in the same household) and relatedness of each dyad.

prefix-dev/rip

2023-10-25T01:40:52Z

Solve and install Python packages quickly with rip (pip in Rust)

RIP: Fast, barebones pip implementation in Rust

RIP is a library that allows the resolving and installing of Python PyPI packages from Rust into a virtual environment. It's based on our experience with building Rattler and aims to provide the same experience but for PyPI instead of Conda. It should be fast and easy to use. Like Rattler, this library is not a package manager itself but provides the low-level plumbing to be used in one.

RIP is based on the quite excellent work of posy and we have tried to credit the authors where possible.

Showcase

Let's resolve the flask python package. We've added a small binary to showcase this:

This showcases the downloading and caching of metadata from PyPI. As well as the package resolution using our solver, more on this below. We cache everything in a local directory so that we can re-use the metadata and don't have to download it again.

Features

This is a list of current and planned features of RIP, the biggest are listed below:

Downloading and aggressive caching of PyPI metadata.
Resolving of PyPI packages using Resolvo.
Installation of wheel files (partial support see: https://github.com/prefix-dev/rip/issues/6)
Support sdist files (planned)

More intricacies of the PyPI ecosystem need to be implemented, see our GitHub issues for more details.

Solver

We have integrated the stand-alone packaging SAT solver Resolvo, to resolve pypi packages. This solver is incremental and adds packaging metadata during resolution of the SAT problem. This feature can be enabled with the resolvo feature flag.

Contributing 😍

We would love to have you contribute! See the CONTRIBUTING.md for more info. For questions, requests or a casual chat, we are very active on our discord server. You can join our discord server via this link.

Nukesor/pueue

2023-10-25T01:40:52Z

🌠 Manage your shell commands.

Pueue

Pueue is a command-line task management tool for sequential and parallel execution of long-running tasks.

Simply put, it's a tool that processes a queue of shell commands. On top of that, there are a lot of convenient features and abstractions.

Since Pueue is not bound to any terminal, you can control your tasks from any terminal on the same machine. The queue will be continuously processed, even if you no longer have any active ssh sessions.

Pueue is considered feature-complete 🎉. All features that were planned have been added and only minor improvements, bug-fixes and regular maintenance work will get merged.

Features

Scheduling
- Add tasks as you go.
- Run multiple tasks at once. You decide how many tasks should run concurrently.
- Change the order of the scheduled tasks.
- Specify dependencies between tasks.
- Schedule tasks to run at a specific time.
Process interaction
- Easy output inspection.
- Send input to running processes.
- Pause/resume tasks, when you need some processing power right NOW!
Task groups (multiple queues)
- Each group can have several tasks running in parallel.
- Pause/start tasks by a group.
Background process execution
- The pueued daemon runs in the background. No need to be logged in.
- Commands are executed in their respective working directories.
- The current environment variables are copied when adding a task.
- Commands are run in a shell which allows the full feature set of shell coding.
Consistency
- The queue is always saved to disk and restored on kill/system crash.
- Logs are persisted onto the disk and survive a crash.
Miscellaneous
- A callback hook to, for instance, set up desktop notifications.
- JSON output for log and status if you want to display info about tasks in another program.
- A wait subcommand to wait for specific tasks, a group (or everything) to finish.
A lot more. Check the -h options for each subcommand for detailed options.
Cross Platform
- Linux is fully supported and battle-tested.
- MacOS is fully supported and on par with Linux.
- Windows is fully supported and working fine for quite a while.
Why should I use it
Advantages over Using a Terminal Multiplexer

What Pueue is not

Pueue is not designed to be a programmable (scriptable) task scheduler/executor.

The focus of pueue lies on human interaction, i.e. it's supposed to be used by a real person on some kind of OS. See the Design Goals section

Due to this, the feature set of pueue and pueued as well as their implementation and architecture have been kept simple by design! Even though it can be scripted to some degree, it hasn't been built for this and there's no official support!

There's definitely the need for a complex task scheduler/executor with advanced API access and scheduling options, but this is the job for another project, as this is not what pueue has been built for.

Installation

There are a few different ways to install Pueue.

Package Manager

The preferred way to install Pueue is to use your system's package manager. This will usually deploy service files and completions automatically.

Pueue has been packaged for quite a few distributions, check the table on the right for more information.

Prebuild Binaries

Statically linked (if possible) binaries for Linux (incl. ARM), Mac OS and Windows are built on each release.
You can download the binaries for the client and the daemon (pueue and pueued) for each release on the release page.
Just download both binaries for your system, rename them to pueue and pueued and place them in your $PATH/program folder.

Via Cargo

Pueue is built for the current stable Rust version. It might compile on older versions, but this isn't tested or officially supported.

cargo install --locked pueue

This will install Pueue to $CARGO_HOME/bin/pueue (default is ~/.cargo/bin/pueue)

From Source

Pueue is built for the current stable Rust version. It might compile on older versions, but this isn't tested or officially supported.

git clone git@github.com:Nukesor/pueue
cd pueue
cargo build --release --locked --path ./pueue

The final binaries will be located in target/release/{pueue,pueued}.

How to Use it

Check the wiki to get started :).

There are also detailed sections for (hopefully) every important feature:

On top of that, there is a help option (-h) for all commands.

Interact with the Pueue daemon

Usage: pueue [OPTIONS] [COMMAND]

Commands:
  add            Enqueue a task for execution.
                     There're many different options when scheduling a task.
                     Check the individual option help texts for more information.

                     Furthermore, please remember that scheduled commands are executed via your system shell.
                     This means that the command needs proper shell escaping.
                     The safest way to preserve shell escaping is to surround your command with quotes, for example:
                     pueue add 'ls $HOME && echo "Some string"'
  remove         Remove tasks from the list. Running or paused tasks need to be killed first
  switch         Switches the queue position of two commands. Only works on queued and stashed commands
  stash          Stashed tasks won't be automatically started. You have to enqueue them or start them by hand
  enqueue        Enqueue stashed tasks. They'll be handled normally afterwards
  start          Resume operation of specific tasks or groups of tasks.
                     By default, this resumes the default group and all its tasks.
                     Can also be used force-start specific tasks.
  restart        Restart failed or successful task(s).
                     By default, identical tasks will be created and enqueued, but it's possible to restart in-place.
                     You can also edit a few properties, such as the path and the command, before restarting.
  pause          Either pause running tasks or specific groups of tasks.
                     By default, pauses the default group and all its tasks.
                     A paused queue (group) won't start any new tasks.
  kill           Kill specific running tasks or whole task groups..
                     Kills all tasks of the default group when no ids or a specific group are provided.
  send           Send something to a task. Useful for sending confirmations such as 'y\n'
  edit           Edit the command, path or label of a stashed or queued task.
                     By default only the command is edited.
                     Multiple properties can be added in one go.
  group          Use this to add or remove groups.
                     By default, this will simply display all known groups.
  status         Display the current status of all tasks
  format-status  Accept a list or map of JSON pueue tasks via stdin and display it just like "pueue status".
                     A simple example might look like this:
                     pueue status --json | jq -c '.tasks' | pueue format-status
  log            Display the log output of finished tasks.
                     Only the last few lines will be shown by default.
                     If you want to follow the output of a task, please use the "follow" subcommand.
  follow         Follow the output of a currently running task. This command works like "tail -f"
  wait           Wait until tasks are finished.
                     By default, this will wait for all tasks in the default group to finish.
                     Note: This will also wait for all tasks that aren't somehow 'Done'.
                     Includes: [Paused, Stashed, Locked, Queued, ...]
  clean          Remove all finished tasks from the list
  reset          Kill all tasks, clean up afterwards and reset EVERYTHING!
  shutdown       Remotely shut down the daemon. Should only be used if the daemon isn't started by a service manager
  parallel       Set the amount of allowed parallel tasks
                     By default, adjusts the amount of the default group.
                     No tasks will be stopped, if this is lowered.
                     This limit is only considered when tasks are scheduled.
  completions    Generates shell completion files. This can be ignored during normal operations
  help           Print this message or the help of the given subcommand(s)

Options:
  -v, --verbose...         Verbose mode (-v, -vv, -vvv)
      --color <COLOR>      Colorize the output; auto enables color output when connected to a tty [default: auto] [possible values: auto, never, always]
  -c, --config <CONFIG>    Path to a specific pueue config file to use. This ignores all other config files
  -p, --profile <PROFILE>  The name of the profile that should be loaded from your config file
  -h, --help               Print help
  -V, --version            Print version

Design Goals

Pueue is designed to be a convenient helper tool for a single user.

It's supposed to work stand-alone and without any external integration. The idea is to keep it simple and to prevent feature creep.

Also, Pueue is considered feature-complete 🎉. All features that were planned have been added and only minor improvements, bug-fixes and regular maintenance work will get merged.

For the record, the follwing features weren't included as they're out of scope:

Distributed task management/execution.
Multi-user task management.
Sophisticated task scheduling for optimal load balancing.
Tight system integration or integration with external tools.
Explicit support for scripting. If you're adamant about scripting it anyway, take a look at the pueue-lib library, which provides proper API calls for pueued. However, keep in mind that pueued is still supposed to be a minimalistic task executor with as little scheduling logic as possible.

There seems to be the need for some project that satisfies all these points mentioned above, but that will be the job of another tool. I very much encourage forking Pueue and I would love to see forks grow into other cool projects!

Similar Projects

GNU Parallel

A robust and featureful parrallel processor with text-based joblog and n-retries. GNU Parallel is able to scale to multi-host parallelization and has complex code to have deep integration across different tools and shells, as well as other advanced features. Pueue differentiates itself from GNU Parallel by focusing more on visibility across many different long running commands, and creating a central location for commands to be stored, rather than GNU Parallel's focus on chunking a specific task.

nq

A very lightweight job queue systems which require no setup, maintenance, supervision, or any long-running processes.
Link to project

task-spooler

task spooler is a Unix batch system where the tasks spooled run one after the other.
Links to ubuntu manpage and a fork on Github. The original website seems to be down.

Contributing

Feature requests and pull requests are very much appreciated and welcome!

Anyhow, please talk to me a bit about your ideas before you start hacking! It's always nice to know what you're working on and I might have a few suggestions or tips :)

Depending on the type of your contribution, you should branch of from either the main branch or the development branch.

Bug fixes or critical library updates should branch of main and be merged into main. New patch level releases will be published for this kind of issues. Any patches in main will also regularily be merged into development.
Everything else, such as new features, refactorings, or breaking changes, should branch of development and be merged into development. Once a new minor or major version has been published, development will then be merged into main.

There's also the Architecture Guide, which is supposed to give you a brief overview and introduction to the project.

comsec-group/cascade-artifacts

2023-10-26T01:36:05Z

Artifacts for Cascade: CPU Fuzzing via Intricate Program Generation (USENIX Security 2024)

Artifacts Evaluation - README - Usenix Security 2024

For Paper: Cascade: CPU Fuzzing via Intricate Program Generation

Overview

Welcome to the artifacts for Cascade! This repository will help you reproduce the results presented in our paper, and will get you started with Cascade without worrying too much about setting up the context. For more information about Cascade, visit https://comsec.ethz.ch/cascade

The repository is structured as follows. First, we indicate a few requirements. Second, we provide a step-by-step guide to reproduce the results in our paper.

We recommend using the provided Docker image to reproduce the results. All experiments, except the Questasim experiment, run inside a Docker container. The Questasim experiment is optional as its only purpose is to compare the simulator coverage of Cascade and TheHuzz.

Requirements

Some experiments require 64 cores, however, it can be run with less cores, we do not expect a big difference in the results.

One optional experiment, which will be explicitly marked, requires access to Questasim (a commercial RTL simulator). No other experiment depends on these results, hence non-Questasim users can safely ignore this experiment and run the rest of the artifacts.

Step-by-step guide

Obtain the Docker image. (Human time: 1 minute. Computer time: up to some hours.)

If you are willing to use the Docker image, here is how to proceed. Else, we recommend to mimic the structure of the repositories as described in the Dockerfile.

docker pull docker.io/ethcomsec/cascade-artifacts

Start a container using the Docker image. (Human time: some minutes, on and off. Computer time: some minutes.)

All relevant experiments have already been reproduced inside this image. We made the steps explicit in the Dockerfile. The Dockerfile is hence also a convenient reference on how to run each experiment.

First, start a new container with the image:

docker run -it docker.io/ethcomsec/cascade-artifacts

This procedure assumes you don't want to rebuild everything from scratch, although you can re-run commmands that are presented in the Dockerfile.

Instead, if you would like to rebuild the Docker image, simply run make build in the current repository, which will re-build the whole Docker image from scratch. This will take many hours to execute.

In this Docker container, we limited the computation for Figure 16 to 30 seconds per point to finish in reasonable time. The value used in the paper is 1200 seconds, which may require multiple days to run, on a 64-core machine. The duration of 30 seconds is sufficient to support the claim made in the paper that longer programs tend to be more efficient at finding bugs. This timeout can be modified by adapting the line ENV TIMEOUT_SECONS_PER_BUG=30 in the Dockerfile with a value of your choice.

The following error messages are expected, and can be safely ignored:

SIMLEN environment variable not set.
make: *** [Makefile:129: run_vanilla_notrace] Error 1

Re-running individual experiments

You can re-run individual experiments by re-executing lines of the Dockerfile in the docker container.

Make sure that your Verilator version in the Docker container is correct. If you get the following error:

ERROR: %Error: Unknown warning specified: -Wno-EOFNEWLINE

Then please reinstall the newer version of Verilator:

rm -rf verilator && git clone https://github.com/verilator/verilator && cd verilator && git checkout v5.006 && autoconf && ./configure && make -j 200 && make install

Plots

All plots, except for the Questasim experiment, are stored in the /cascade-meta/figures directory inside the Docker container, and have been generated as indicated in the Dockerfile.

Extracting plots from the Docker container

You must first run a container, for example using the command make run. You can then see the container id, for example, from the command prompt that you get after running make run, for example, root@ac674f329a7b:/# signifies that the container id is ac674f329a7b.

You can now copy out the figures from the container to your host machine, for example, using the following commands:

mkdir -p figures
docker cp <container_id>:/cascade-meta/figures/bug_categories.png            figures
docker cp <container_id>:/cascade-meta/figures/cascade_dependencies.png      figures
docker cp <container_id>:/cascade-meta/figures/cascade_prevalences.png       figures
docker cp <container_id>:/cascade-meta/figures/difuzzrtl_completions.png     figures
docker cp <container_id>:/cascade-meta/figures/difuzzrtl_coverage.png        figures
docker cp <container_id>:/cascade-meta/figures/difuzzrtl_dependencies.png    figures
docker cp <container_id>:/cascade-meta/figures/difuzzrtl_prevalences.png     figures
docker cp <container_id>:/cascade-meta/figures/reduction_perf.png            figures
docker cp <container_id>:/cascade-meta/figures/rfuzz.png                     figures
docker cp <container_id>:/cascade-meta/figures/security_implications.png     figures
docker cp <container_id>:/cascade-meta/figures/bug_timings_curves.png        figures
docker cp <container_id>:/cascade-meta/figures/execperf_programlength.png    figures
docker cp <container_id>:/cascade-meta/figures/fuzzperf_programlength.png    figures
docker cp <container_id>:/cascade-meta/figures/genduration_programlength.png figures
docker cp <container_id>:/cascade-meta/figures/fuzzperf.png                  figures

Mapping to the paper's figures

Mapping to the paper's figures:

Figure in paper	Figure in artifacts
1	difuzzrtl_completions
2	difuzzrtl_prevalences
3	-
4	-
5	-
6	fuzzperf
7	execperf_programlength
8	genduration_programlength
9	fuzzperf_programlength
10	cascade_prevalences
11	difuzzrtl_dependencies
12	cascade_dependencies
13	difuzzrtl_coverage
14	rfuzz
15	[optional -- modelsim]
16	bug_timings_curves
17	bug_categories
18	bug_detection_timings
19	security_implications
20	reduction_perf

Questasim experiment (Optional)

The Questasim experiment, optional, is the only experiment that must be partially run outside of the Docker container. The experiment requires the presence of the executables vsim, vlog and vcover in the PATH.

You will also require fusesoc, as also installed in the Dockerfile.

pip3 install fusesoc

You will need to clone cascade-meta and cascade-chipyard (containing the Rocket core) locally. If potential requirements are missing, ensure to reproduce the first line of the Dockerfile, directly on your machine.

To initialize cascade-chipyard, please run, like done in the Dockerfile:

source /path/to/cascade-meta && cd /path/to/cascade-chipyard && git branch stable && CASCADE_JOBS=250 scripts/init-submodules-no-riscv-tools.sh -f

Then, build the Rocket core for the Questasim simulation:

source /path/to/cascade-meta && cd /path/to/cascade-chipyard/cascade && make build_vanilla_notrace_modelsim && make rerun_vanilla_notrace_modelsim

You may have to adapt the rocket entry in the local cascade_meta/design_processing/design_repos.json for running the experiment.

To run the Questasim experiment, first start a new container with the image and generate the ELF files for DifuzzRTL and Cascade (this may take some hours). Note that we could have done this in the Dockerfile but the resulting Docker image would be very large. You must also choose a local directory where the ELFs directory will be mounted (make sure to have the proper permissions); alternatively, instead of mounting using the -v flag, you could copy out the ELFs by using docker ps and then docker cp. All this can be done, for example, as follows:

DIFUZZRTL_FUZZER_DIR_PATH_CANDIDATE=<path_to_the_Fuzzer> docker run -v /path/to/some/mount/directory:/cascade-mountdir -it cascade-artifacts bash -c "source /cascade-meta/env.sh && python3 /cascade-meta/fuzzer/do_genelfs_for_questa.py"

Ensure that you have the Python requirements installed by the Dockerfile on your host machine. Please install any additional Python requirement that would be requested during the course of the experiment, for instance:

pip3 install matplotlib numpy tqdm filelock

Finally, run the experiment, first indicating where the ELFs are now located (the directory you mounted):

export CASCADE_PATH_TO_DIFUZZRTL_ELFS_FOR_MODELSIM=/path/to/some/mount/directory
cd <path_to_cascade_meta>/fuzzer && python3 do_compare_cascade_difuzzrtl_modelsim.py

The experiment may take many hours and can be divided in two parts:

Running the fuzzer. This can be done in parallel.
Merging the coverage results. This must be done sequentially to get the coverage achieved at each step. The result is stored in the file modelsim.png in the local cascade-meta/figures directory.

hmrc/emcs-tfe-create-movement-frontend

2023-10-26T01:36:05Z

emcs-tfe-create-movement-frontend

Contains the frontend journey for EMCS TFE to Create a Movement. Using hmrc-scaffold-g8.

How to build pages with the Scaffoling

Enter an sbt shell by issuing the command sbt in your terminal window. (alternative, if using IntelliJ click on the sbt shell tab in the bottom panel)
Once the sbt shell has initialised enter the command g8Scaffold template where template is replaced with one of the following available scaffolding templates:
1. checkboxPage
2. contentPage
3. datePage
4. intPage
5. multipleQuestionsPage
6. radioButtonPage
7. stringPage
8. yesNoPage
9. characterCountPage
The g8Scaffolding will prompt for values to properties. Such as the className
Enter appropriate values for each prompt
Once the g8Scaffold says success :), exit out of the sbt shell and back to a normal terminal window
Run the script ./migrate.sh to run the migrations (this creates the messages entries and the routes entries - along with a few other things)
Your page is ready to be refactored and enhanced with business rules, content changes and anything else.
IMPORTANT:
1. Using the scaffolds to generate tests is not a replacement for writing good tests. Please refactor and enhance the default tests with tests which cover extra logic and business rules
2. Scaffold are here to help us get a head start with simple pages, but do refactor the generated code to improve quality where appropriate
3. If you find an improvement that could be applied to the Scaffolds update the g8 template so that this can be used by future Engineers

License

This code is open source software licensed under the Apache 2.0 License.

raghuteja/Dots-and-Boxes

2023-10-26T01:36:02Z

Written in Sceme language (A Project @iitB)

hovgaardgames/website-hovgaard-theme

2023-10-25T01:41:22Z

Vitepress theme for Hovgaard Games

yandex-praktikum/git-fork-case

2023-10-25T01:41:27Z

Repository for git fork case.

git-fork-case

Repository for git fork case.

vitkarpov/coding-interviews-blog-archive

2023-10-25T01:41:27Z

Разбор задач для алгоритмических интервью в Big Tech

Coding Interviews in a Nutshell

"Coding Interviews In a Nutshell" is a comprehensive guide to excel in coding interviews, especially in Big Tech companies. It doesn't require prior computer science or math knowledge, making it accessible to self-taught developers (in Russian)

dell/helm-charts

2023-10-25T01:41:58Z

The source for Dell Helm charts.

batoulalkarim/protecc

2023-10-26T01:36:48Z

liruoyu2008/blog

2023-10-26T01:37:05Z

个人博客

syntaxfm/website

2023-10-26T01:37:10Z

Syntax Podcast Website

osc-vitap/OpenSource101

2023-10-26T01:37:10Z

This is a starter repository made specifically so we can help you get your first pull request and learn the basics of Git and GitHub.

rarfell/dimeApp

2023-10-26T01:37:16Z

Dime is a beautiful expense tracker built with iOS design guidelines in mind.

Dime

A 100% free personal finance tracker built with iOS design guidelines in mind. Download Dime on the App Store.

App Preview

Why You’ll Love Dime

100% free forever, with no paywall or ads.
Beautifully iOS-centric design, with simplicity at its core.
Insightful expenditure breakdowns over various time periods.
Create budgets based on expense categories and stick to them.
Create recurring expenses with custom time frames.
Sync your expenses, categories and budgets with other devices via iCloud.
Custom reminders to input your expenses.
Biometric authentication to protect your data.
Home screen quick actions make capturing new expenses a breeze.
A gorgeous night theme for dark mode fanatics.
Informative home and lock screen widgets keep you updated at a glance.

Licence

This project is licensed under the GNU General Public License v3.0 - see the LICENSE file for details.

lukstafi/curious-ocaml

2023-10-26T01:37:26Z

A curious book about OCaml: logic (types), algebra (values), computation (rewrite semantics), functions (lambda calculus), constraints, monads, expression.

OrangeX4/NJUAI-Notes

2023-10-26T01:37:30Z

我在南京大学人工智能专业学习时所做的笔记 :-)

JuliaEarth/geospatial-data-science-with-julia

2023-10-25T01:43:02Z

Geospatial Data Science with Julia

This repository hosts the source code of the book Geospatial Data Science with Julia.

The book is available online for free at https://juliaearth.github.io/geospatial-data-science-with-julia

Build instructions

To build this book, you need:

Julia v1.9
IJulia (>= v1.24)
```
import Pkg
Pkg.add("IJulia")
```
Quarto VSCode extension

Open the Julia REPL and instantiate the environment in this folder:
```
import Pkg
Pkg.activate(".")
Pkg.instantiate()
```
Go to any *.qmd file and press render on VSCode. Alternatively, run the following in the terminal:
```
quarto preview index.qmd
```

Your web browser will open a tab with the book rendered.

Traverse-Research/Volumetric-data-structures-for-real-time-ray-tracing

2023-10-25T01:43:02Z

All documents related to my master thesis

🌪️`Volumetric data structures for real-time ray tracing`

This repository contains all documents related to the master thesis by Rosalie de Winther on volumetric data structures. The main document can be found here.

Presentations

Presentations regarding this subject:

Results

Half resolution Disney Cloud

Animated chimney in Bistro scene (click for youtube video)

aws-samples/bedrock-claude-chat

2023-10-25T01:43:35Z

AWS-native chatbot using Bedrock + Claude 2

Bedrock Claude Chat

日本語はこちら

Warning The current version (v0.2.x) has no compatibility with ex version (v0.1.0) due to the change of the conversation schema. Please note that conversations stored in DynamoDB with ex version cannot be rendered.

This repository is a sample chatbot using the Anthropic company's LLM Claude 2, one of the foundational models provided by Amazon Bedrock for generative AI.

Architecture

It's an architecture built on AWS managed services, eliminating the need for infrastructure management. Utilizing Amazon Bedrock, there's no need to communicate with APIs outside of AWS. This enables deploying scalable, reliable, and secure applications.

Amazon DynamoDB: NoSQL database for conversation history storage
Amazon API Gateway + AWS Lambda: Backend API endpoint (AWS Lambda Web Adapter, FastAPI)
Amazon SNS: Used to decouple streaming calls between API Gateway and Bedrock because streaming responses can take over 30 seconds in total, exceeding the limitations of HTTP integration (See quota).
Amazon CloudFront + S3: Frontend application delivery (React, Tailwind CSS)
AWS WAF: IP address restriction
Amazon Cognito: User authentication
Amazon Bedrock: Managed service to utilize foundational models via APIs

Features and Roadmap

Authentication (Sign-up, Sign-in)
Creation, storage, and deletion of conversations
Copying of chatbot replies
Automatic subject suggestion for conversations
Syntax highlighting for code
Rendering of Markdown'
Streaming Response
IP address restriction
Edit message & re-send
I18n (English / Japanese)
Save and re-use prompt template

Deployment

🚀 Easy Deployment

Note: Bedrock currently does NOT support all regions. Following procedure will deploy Bedrock resource to us-east-1 (Other resources will be deployed on the region where the CloudShell run). If you need to change the Bedrock region, follow the instructions later in this chapter to deploy using CDK directly.

Open CloudShell
Clone this repository

git clone https://github.com/aws-samples/bedrock-claude-chat.git

Run deployment via following commands

cd bedrock-claude-chat
chmod +x bin.sh
./bin.sh

After about 10 minutes, you will get the following output, which you can access from your browser

Frontend URL: https://xxxxxxxxx.cloudfront.net

The sign-up screen will appear as shown above, where you can register your email and log in.

Deploy using CDK

Easy Deployment uses AWS CodeBuild to perform deployment by CDK internally. This section describes the procedure for deploying directly with CDK.

Please have UNIX commands and a Node.js runtime environment. If not, you can also use Cloud9
Clone this repository

git clone https://github.com/aws-samples/bedrock-claude-chat

Install npm packages

cd bedrock-claude-chat
cd cdk
npm ci

Install AWS CDK

npm i -g aws-cdk

Before deploying the CDK, you will need to work with Bootstrap once for the region you are deploying to. In this example, we will deploy to the us-east-1 region. Please replace your account id into <account id>.

cdk bootstrap aws://<account id>/us-east-1

If necessary, edit the following entries in [cdk.json](. /cdk/cdk.json) if necessary.
- bedrockRegion: Region where Bedrock is available.
- allowedIpV4AddressRanges, allowedIpV6AddressRanges: Allowed IP Address range.
Deploy this sample project

cdk deploy --require-approval never --all

You will get output similar to the following. The URL of the web app will be output in BedrockChatStack.FrontendURL, so please access it from your browser.

 ✅  BedrockChatStack

✨  Deployment time: 78.57s

Outputs:
BedrockChatStack.AuthUserPoolClientIdXXXXX = xxxxxxx
BedrockChatStack.AuthUserPoolIdXXXXXX = ap-northeast-1_XXXX
BedrockChatStack.BackendApiBackendApiUrlXXXXX = https://xxxxx.execute-api.ap-northeast-1.amazonaws.com
BedrockChatStack.FrontendURL = https://xxxxx.cloudfront.net

Others

Configure text generation parameters

Edit config.py and run cdk deploy.

GENERATION_CONFIG = {
    "max_tokens_to_sample": 500,
    "temperature": 0.6,
    "top_k": 250,
    "top_p": 0.999,
    "stop_sequences": ["Human: ", "Assistant: "],
}

Delete Resources

If you are using the CLI and CDK, run cdk destroy. Otherwise, access CloudFormation and manually delete the BedrockChatStack and FrontendWafStack stacks. FrontendWafStack is in the us-east-1 region.

Language Settings

This asset automatically detects the language using i18next-browser-languageDetector.You can switch languages from the application menu. Alternatively, you can use Query String to set the language as shown below.

https://example.com?lng=ja

Local Frontend Development

In this sample, you can locally modify and launch the frontend using AWS resources (API Gateway, Cognito, etc.) that have been deployed with cdk deploy.

Refer to Deploy using CDK for deploying on the AWS environment.
Copy the frontend/.env.template and save it as frontend/.env.local.
Fill in the contents of .env.local based on the output results of cdk deploy (such as BedrockChatStack.AuthUserPoolClientIdXXXXX).
Execute the following command:

cd frontend && npm run dev

Using Streaming

Currently, the environment variable VITE_APP_USE_STREAMING is specified on the frontend side. It's recommended to set it to false when running the backend locally and true when operating on AWS.
When streaming is enabled, text is generated in real-time due to the streaming of content generation results.

Local development using docker compose

docker-compose.yml allows you to run and develop frontend/backend APIs/DynamoDB Local in your local environment.

# Build containers
docker compose build

# Launch containers
docker compose up

# Stop containers
docker compose down

Remove resources

If using cli and CDK, please cdk destroy. If not, access to CloudFormation then delete BedrockChatStack and FrontendWafStack manually. Please note that FrontendWafStack is on us-east-1 region.

RAG using Kendra

In this sample, we have not implemented RAG using Kendra. This is because when it comes to real-world deployments, factors such as access control policies, the presence or absence of data connectors, and the methods for authentication and authorization for the connected data sources can be quite diverse depending on the organization, making it difficult to generalize them in a simple manner. To put this into practice, you should consider downsides like decreased latency and increased token consumption. For these reasons, a proof of concept (PoC) to verify search accuracy is essential.

generative-ai-use-cases-jp (In Japanese)
simple-lex-kendra-jp (In Japanese)
jp-rag-sample (In Japanese)

Authors

analogjs/analog

2023-10-25T01:43:35Z

Build and ship applications and websites faster with Angular

Analog

Analog is a meta-framework for building applications and websites with Angular.

Similar to other meta-frameworks such as Next.JS, Nuxt, SvelteKit and others, Analog provides a similar experience, building on top of Angular.

Documentation

Visit the docs at https://analogjs.org

Features

Supports Vite/Vitest/Playwright
File-based routing
Support for using markdown as content routes
Support for API/server routes
Hybrid SSR/SSG support
Supports Angular CLI or Nx workspaces

Getting Started

Use your package manager of choice to create a new project

With yarn:

yarn create analog

With npm:

npm init analog

With pnpm:

pnpm create analog

Follow the prompts to scaffold the project and start the development server.

Supporting Analog

Analog is an MIT-licensed open source project with its ongoing development made possible by contributors and sponsors.

Become a Sponsor!.

Contributing

Analog welcomes contributors! Please read the contributing doc for details.

Credits

The name was inspired by this project https://github.com/rrdelaney/Analog.

Contributors ✨

Thanks goes to these wonderful people for contributing to Analog (emoji key):

_Brandon 💻 📖 🤔	_{Lars Gyrup Brink Nielsen} 📖 ⚠️	_{Marko Stanimirović} 🔧 🚇 📖 💻 🎨	_{Jason Hodges} 📖	_{Tim Deschryver} 🚇	_{Dale Nguyen} 💻 🎨	_{Andrés Villanueva} 📖 🌍
_{Umair Hafeez} 🚇	_{Brandon Largeau} 🚇	_{Maina Wycliffe} 💻 🚇	_{Preston Lamb} 💻 📖	_{Andrew Luca} 💻	_{Chau Tran} 💻 🚇	_Simone 💻
_{Kyler Johnson} 💻	_Marc 📖 💻	_himyjan 💻	_{Alex Kovalev} 📖	_{Nuhman Pk} 📖	_{Miloš Lajtman} 💻	_profanis 💻
_{Reece McDonald} 📖	_{Matteo Pietro Dazzi} 💻	_{Lukáš Matta} 📖	_Luciano 📖	_{Robin Goetz} 💻	_{Vadim Evseev} 💻	_{Danny Koppenhagen} 📖 💻
_{Tomasz Flis} 📖	_{AdditionAddict} 📖 💻	_Sander 💻	_{Chris Perko} 💻 📖	_{Christian Lüdemann} 💻	_Yasser 💻	_{Michał Dyrcz} 💻
_{Otoniel Guajardo} 📖	_gergobergo 💻	_saurajit 📖	_{Mircea Rilă} 📖 🚇	_Dominik 📖 💻 🚇	_{Henrique Custódia} 📖	_{ISODA Yu} 📖
_{Cynthia Iradukunda} 📖	_Drunkenpilot 📖 💻	_{Jeremy Hofer} 📖 💻 🚇	_{Olalekan Raheem} 📖	_{Luis Castro} 💻 📖 🌍	_Q 💻 📖	_{Glenn Latomme} 📖
_{Justin Rassier} 📖 💻 🚇	_{Matthieu Riegler} 📖 🚇 💻	_{Ashley Hunter} 💻	_{Artur Androsovych} 💻 📖	_{Bjorn Lu} 🚇	_{Omar BELKHODJA} 💻	_{Deepak Rudra Paul} 📖
_{Michael Avrukin} 📖	_{Rafael Mestre} 💻 📖 🚇	_{Santosh Yadav} 📖	_Tenessy 🚇 💻 ⚠️	_{Jad Chahed} 📖 🌍	_{Gesiel Rosa} 📖 🌍	_{Besim Gürbüz} 📖 🌍
_{Lukas Nys} 📖	_{Andreas Ländle} 💻

This project follows the all-contributors specification. Contributions of any kind welcome!

electron-vite/electron-vite-vue

2023-10-26T01:37:56Z

🥳 Really simple Electron + Vite + Vue boilerplate.

electron-vite-vue

🥳 Really simple Electron + Vue + Vite boilerplate.

Features

📦 Out of the box
🎯 Based on the official template-vue-ts, less invasive
🌱 Extensible, really simple directory structure
💪 Support using Node.js API in Electron-Renderer
🔩 Support C/C++ native addons
🖥 It's easy to implement multiple windows

Quick Setup

# clone the project
git clone https://github.com/electron-vite/electron-vite-vue.git

# enter the project directory
cd electron-vite-vue

# install dependency
npm install

# develop
npm run dev

Debug

FAQ

ZachGoldberg/Startup-CTO-Handbook

2023-10-25T01:23:16Z

Curso para aprender los fundamentos del lenguaje SQL y bases de datos relacionales desde cero y para principiantes. Elaborado durante las emisiones en directo desde Twitch de MoureDev.

daveshap/SparsePrimingRepresentations

2023-10-25T01:23:16Z

Public repo to document some SPR stuff

Chuny1/3DGPT

2023-10-25T01:23:16Z

An custom Roblox UWP Client that is customizable and user friendly

msanders/cocoa.vim

2023-10-26T01:38:18Z

Vim plugin for Cocoa/Objective-C development. No longer actively developed.

lmxdawn/vue-admin-html-java

2023-10-25T01:44:06Z

spring boot + mybatis + vue + element-ui 实现后台管理API接口

dromara/mayfly-go

2023-10-26T01:38:26Z

web版linux(终端文件脚本进程)、数据库(mysql pgsql)、redis(单机哨兵集群)、mongo统一管理操作平台。

oleksiizozulenko/performance-scripts-demo

2023-10-25T01:44:31Z

Scripts for running performance tests

== Running scenarios ==

Performance (Load) did as simple as possible. Base principle - just one environment in one time but it's possible to run different scenarios.

== Script run-tests.sh command line arguments == All command line arguments have formant [parameter]=[value]

{| class="wikitable" border="1" cellpadding="5" cellspacing="0" width="100%" ! align="center" style="width:200pt; " scope="col" | Parameter ! style="width:100pt;" scope="col" | Description

|- | --results-dir | Directory where to save results '''default:''' ${user.home}/performance-results/ ''tip:'' when you didn't set results dir and default directory not found then all resutls will be stored in folder [ dirname run-scripts.sh]/results/

|- | --users | How many virtual users will be started. '''default:''' 10

|- | --duration in seconds | How much time scenario will be running. '''default:''' 15 min

|- | --rampup in seconds | How much time jmeter start threads. Used for calculate load profile. '''default:''' 1 sec

|- | --delay in seconds | Startup delay. How much time jmeter wait before start scenario. '''default:''' 0

|- | --scenarios | Names of scenarios for run. You can set few space-separated. Example --scenarios="TestScriptName1 TestScriptName2 TestScriptNameN". '''default:''' run-all

|- | --env-id | Benchmark site id. Configured in config.properties file in format ''' bmk.host.[bmk.id].id ''' where this bmk.id you will set as --env-id property This parameter is required

|- | --perf-host | dns of bmk server where serverAgent is running. '''default:''' nis1-dev2.srvlanlocal

|- | --perfmon | Enables Performance monitor plugin '''default:''' true

|- | --perf-port | port for serverAgent. '''default:''' 4545

|- | --loadosophia | Enables Loadosophia plugin. '''default:''' false

==== Example: ====

/bin/bash run-tests.sh --users=15 --duration=3600 --env-id=1 --scenarios="TestScriptName1 TestScriptName2"

will run scenarios '''TestScriptName1''' and '''TestScriptName2''' on environment with id 1 ( bmk1host1.example.com ) for 1 hour and 15 parallel threads (virtual users)

=== For Windows Workstantions === For windows workstantion you can use next command for running scenarios

[your repository location]\tools\ant\bin\ant.bat -DANT_OPTS="-Xmx5128m -Xms1024m" -Drun.env.id=[your env.id] -Dresults.dir=[your results folder *required] -Duser.count=[your users count] -Drun.duration=[your run duration] [space separated names of scenarios]

==== Example: ====

 
 
  C:\alex\obb-performance\tools\ant\bin\ant.bat -DANT_OPTS="-Xmx5128m -Xms1024m" -Drun.env.id=1 -Dresults.dir=./results/ -Duser.count=5 -Drun.duration=300 TestScriptName

== Parameters that can be changed during runtime == {| class="wikitable" border="1" cellpadding="5" cellspacing="0" ! align="center" |Parameter ! Description

|- | '''user.count''' | amount of virtual users (your load profile). This parameters equals to --users in run-tests.sh

|- | '''run.duration'''
| how much time should scenario run. This parameters equals to --duration in run-tests.sh

|- | '''perf.monitor.server''' | server where located tested site. '''default:''' my.perf.site

|- | '''perf.monitor.port''' | port of perfmon agent. '''default:''' 4444 ; ''Tip:'' for my.perf.site use 4545

|- | '''is.upload.loadosophia''' | If you want to upload to Loadosopia (this requires loadosophia token and project. Note: Read about Loadosophia.org Uploader plugin), '''default''': true

|- | '''is.enable.perf.monitor''' | If you want to enable monitoring server metrics. (this plugin requires serverAgent is running. Note: Read about Performance Monitor Plugin for JMeter). '''default''': true

== Parameters for scenarios ==

You can set some parameters into any scenarios for run them on special cases. Just put additional properties file next to your Scenario file All scenario specified properties are depends on benchmark site and should be stored in file with name

[scenario name].bmk[bmk.id].properties

==== For example: ====

TestScriptTamplate.bmk1.properties will set category and product id for bmk1host1 site

== Reporting ==

For reporting uses two parts: '''html''' file and [https://loadosophia.org/ ]

Html reports generates and sends automatically to [your_email].

If reports uses default mount share when they will be appeard on [your_performance] servers. Links to them you will see in email body.

asterisk/documentation

2023-10-25T01:44:39Z

The Asterisk Documentation Project.

Description

This repository contains the Asterisk Documentation project.

Static Documentation

The static documentation contained in the ./docs/ directory is written directly in markdown. The publish process uses mkdocs and Material for MkDocs to generate the HTML web site. The directory structure is fairly straightforward so if you wish to contribute, you should fork this repository and submit pull requests against files in that directory.

All contributions are subject to the Creative Commons Attribution-ShareAlike 3.0 United States license.

Markdown Flavor

The docs are written in standard markdown, not GitHub Flavored markdown. There are lots of extensions available though. Most of the extensions provided by Material for MkDocs are enabled except those only available to paying sponsors and a few that don't make sense in this environment.

!!! note The conversion process that moved the documentation from the Confluence Wiki used equals signs ===== and dashes ---- to denote headers. The new infrastructure renders those correctly but they do not get added to the page's table of contents. Going forward, you should always use hash signs #, ##, ###, etc to denote headers.

Dynamic Documentation

The dynamic documentation includes the pages generated from Asterisk itself and includes:

AGI_Commands
AMI_Actions
AMI_Events
Asterisk_REST_Interface
Dialplan_Applications
Dialplan_Functions
Module_Configuration

The publish process gets this information directly from the Asterisk CreateDocs job (which runs nightly) and generates markdown. For this reason, all changes to the dynamic documentation need to be made in the Asterisk source code itself.

The AGI, AMI, Dialplan and Module documentation comes from the documentation embedded in the provider modules and generated by CreateDocs running xmldoc dump from the Asterisk CLI. You can also use a core-en_US.xml or full-en_US.xml file generated from a local asterisk build. See below for more information.

The Asterisk_REST_Interface documentation comes from the markdown files generated by CreateDocs running make ari-stubs. You can also use locally generated markdown files. See below for more information.

Build/Test Dependencies

Dependencies for documentation can be installed using the included requirements.txt file.

$ pip3 install -r requirements.txt

If you don't want to install the requirements for the current user or globally, you can create a virtual environment specific to this directory first...

$ python -m venv ./.venv
$ source .venv/bin/activate
(.venv)$ pip3 install -r requirements.txt
# run `deactivate` when done
(.venv)$ deactivate
$

The next time you want to test, you can just activate the virtual environment without needing to install the dependencies again. The .venv directory is already in the .gitignore file.

You'll also need the gh tool to pull down the dynamic documentaiton from the CreateDocs job.

NOTE: The documentation build process no longer uses the mike python package.

Building and Testing the Documentation

Prepare

Everything is done from the documentation repository so, if you haven't already, clone it and check out the main branch.

$ git clone -b main https://github.com/asterisk/documentation
$ cd documentation

Create a Makefile.inc file with some configuration variables. This file must NOT be checked in. Here are the contents to use:

# BUILD_DIR := <somepath>  # Defaults to ./temp

# The following 2 DEPLOY_ variables are only needed if you
# need to deploy the built site to some other repo.
# The nightly job uses this to publish the site to
# GitHub pages.
# DEPLOY_REMOTE := <git_remote>
# DEPLOY_BRANCH := <gh pages branch>  # Defaults to gh-pages

# The comma-separated list of branches for which dynamic
# documentation should be built when doing a `make` without
# specifying BRANCH=<branch>.
BRANCHES := 16,18,19,20

# If you don't want to build the static documentation at all...
# NO_STATIC=yes

# If you don't want the resulting HTML minified, set NO_MINIFY.
# Minification can reduce the space required to host the full
# site by about 30% but it does take over double the time to
# generate the site.
# NO_MINIFY=yes

# If you want to serve the resulting site with mkdocs serve,
# you can specify any additional options to pass to it here:
# SERVE_OPTS := -a [::]:8000

If you're planning on using local sources for the dynamic Asterisk documentation, you'll also need to create a Makefile.<branch>.inc file for each branch.

# If you want to use a local XML file to generate the
# AGI, AMI, Dialplan and Module_Configuration documentation,
# specify it here.
# ASTERISK_XML_FILE := <somepath>/asterisk/doc/core-en_US.xml
#
# If you want to use local markdown files for the ARI
# documentation, specify a path to a directory containing
# the markdown generated by "make ari-stubs".
# ASTERISK_ARI_DIR := <somepath>/asterisk/doc/rest-api
#
# If you want to use local XML but skip processing ARI
# altogether, set this variable to "yes".
# SKIP_ARI := yes

# If either ASTERISK_XML_FILE or ASTERISK_ARI_DIR are not set,
# that documentation source will be downloaded from the
# CreateDocs job.

Build and Deploy

To build the entire site:

$ make

This will build the static pages and the dynamic pages for all branches listed in the BRANCHES variable. The fully functioning site will be created at $(BUILD_DIR)/site. You can serve that directory with make serve, which runs mkdocs serve or a web server of your own choosing. mkdocs serve rebuilds the entire site when it starts so you may want to use a standard web server if you plan on doing this a lot. If you do use make serve, you cna use the SERVE_OPTS variable in Makefile.inc to add additional options to the mkdocs serve command line.

To build just the static pages

$ make BRANCHES=

To build just 2 branches

Building branches does need at least a skeleton static layout so static-setup will be built first if it hasn't already been built.

$ make BRANCHES=18,20

If you only want the skeketon static documentation, you can add NO_STATIC=yes to that command line...

$ make BRANCHES=18,20 NO_STATIC=yes

To build just 1 branch

If you're always going to build just 1 branch's dynamic documentation, you can skip the Makefile.<branch>.inc file and just place everything in the main Makefile.inc:

Makefile.inc:

ASTERISK_XML_FILE := <path>/core-en_US.xml
ASTERISK_ARI_DIR := <path>/rest-api
BRANCHES := 20
NO_STATIC := yes

And just run make.

kingsdigitallab/sdo

2023-10-25T01:44:39Z

Schenker Documents Online

sdo

Schenker Documents Online

jekyllgrim/UniversalFlexibleHUD

2023-10-25T01:44:45Z

Universal flexible HUD for GZDoom