This repository contains the source code for COVID-19 EnsembleVis, a visual analytics system that allows the assessment of ensembles and individual models at the county level, by enabling users to effortlessly navigate through and compare ensemble members considering their space and time dimensions. This visual interface provides an overview summary of ensemble data to assess uncertainty, identifies spatiotemporal trends, i.e., how a group of members change over space and time, and visually identifies differences between two or more ensemble members.

The team includes:

• Sanjana Srabanti (University of Illinois at Chicago)
• G. Elisabeta (Liz) Marai (University of Illinois at Chicago)
• Fabio Miranda (University of Illinois at Chicago)

• Prerequisites
• Pre-processing the data
• Building the project

You will need to install Node.js and Angular to build the interface and Jupyter to preprocess the data. You can install all prerequisites by first installing Anaconda (or miniconda) and running the following command:

conda install nodejs jupyter

COVID-19 EnsembleVis makes use of forecasts collected by the COVID-19 Forecast Hub, a site that maintains up-to-data records for forecasts of COVID-19 cases, deaths and hospitalizations in the US. The data is hosted on their GitHub repository, so in order to pre-process the data, first clone the repository:

git clone https://github.com/reichlab/covid19-forecast-hub

Next, run our parser notebook inside the preprocessing folder. The notebook considers that the COVID-19 Forecast Hub repository was cloned at the same level of the COVID-19 EnsembleVis repository. In other words:

./
../
covid-19-ensemblevis/
covid19-forecast-hub/

The jupyter notebook parser.ipynb will save a json file (models.json) inside the folder vis/src/assets/ containing the pre-processed data required by the interface.

The project was generated with Angular CLI version 12.2.0. First install Angular CLI using npm (the default package manager for Node.js):

npm install –g @angular/cli

Next, run ng build inside the vis folder to build the project, and ng serve to create a server and serve the COVID-19 EnsembleVis application. The interface will be available at http://localhost:4200/.

This Matlab tool calculates the radiator return temperature as based on the performance/rating measures making use of various mean temperature difference approaches.

• Features
• How2Use
• License
• Acknowledgement
• How2Cite
• References

The main idea here is to develop simple and reliable emprical models for residential radiator units so to be used in system level modelling (i.e. at district heating simulations). Hence, this Matlab models estimate the radiator behaviour in terms of return temperature at different operational conditions (e.g. changing heat demand rate at different degrees of supply temperature).

• Four different Matlab functions are given, each basing on different approaches for the radiator excess temperature such as either Logarithmic Mean Temperature Difference (LMTD) – implicit, Geometric Mean Temperature Difference (GTMD) – explicit, or Arithmetic Mean Temperature Difference (AMTD) – explicit.
• Error evaluation are involved for GMTD and AMTD approaches, as error criteria formulated with the approach factor.
• In order to avoid deviations at low flow conditions, Schlapmann factors are included in the AMTD method.

An example script is given: ExampleRadiatorReturnTemperature.m, which illustrates how to use the Matlab functions developed Tr_LMTD.m, Tr_GMTD.m, Tr_AMTD.m, and Tr_AMTD_Schlapmann.m. Please clone or download the whole repository and run this example script!

You are free to use, modify and distribute the code as long as authorship is properly acknowledged. The same applies for the original works ‘XSteam.m’ by Holmgren M.

We would like to acknowledge all of the open-source minds in general for their willing of share (as apps or comments/answers in forums), which has encouraged our department to publish our Matlab tools developed during the PhD study here in GitHub.

This Matlab tool makes use of other original open-source project:

• XSteam by Holmgren M. | Author Description: XSteam provides accurate steam and water properties from 0 – 1000 bar and from 0 – 2000 deg C according to the standard IAPWS IF-97. For accuracy of the functions in different regions see IF-97 (www.iapws.org).

1. Tol, Hİ. radiator_performance-Matlab. DOI: 10.5281/zenodo.1297065. GitHub Repository 2018; https://github.com/DrTol/radiator_performance-Matlab
2. Tol, Hİ. District heating in areas with low energy houses – Detailed analysis of district heating systems based on low temperature operation and use of renewable energy. PhD Supervisors: Svendsen S. & Nielsen SB. Technical University of Denmark 2015; 204 p. ISBN: 9788778773685.

• Phetteplace GE. Optimal design of piping systems for district heating. Hanover, N.H.: U.S. Army Cold Regions Research and Engineering Laboratory; 1995.
• Bøhm B. Energy-economy of Danish district heating systems: A technical and economic analysis. Lyngby, Denmark: Laboratory of Heating and Air Conditioning, Technical University of Denmark; 1988.
• Benonysson A. Dynamic modelling and operational optimization of district heating systems. Lyngby, Denmark: Laboratory of Heating and Air Conditioning, Technical University of Denmark; 1991.
• Heat Emission from Radiators and Heating Panels, link: https://www.engineeringtoolbox.com/heat-emission-radiators-d_272.html
• British Standards Institution. BS EN 442-2:2014: Radiators and convectors – Part 2: Test methods and rating 2014:82.
• Soumerai H. Practical thermodynamic tools for heat exchanger design engineers. New York: Wiley-Interscience; 1987.
• Radson. Kv-calculator_-_03-2012(1).xls 2012:2.
• Schlapmann D. Heat output and surface temperature of room heat emitters [Warmeleitung und oberflachentemperatureen von raumheizkorpern] (German). Heiz Luft Haustechnik 1976;27:317–21.
• Kilkis İB. Equipment oversizing issues with hydronic heating systems. ASHRAE J 1998;40:25–30.

Name: Konjungate
Ticker: KONJ
Type: Hybrid, POS / Masternodes –> POW ends on Block 700000
Algorithm: bmw512
Total Coin Supply: 21 billion
BlockSize (depending on block saturation): 1.525612 MB min – 15.256128 MB max
BlockTime: ~ 30 sec.

Rewards per Block:
Dynamic to Block 6800888 (see image below)
From Block 6800889: 245 KONJ / BLOCK (shared as follow)

Dynamic reward structure.

Masternode Collateral: 2750000 KONJ

Charity fee: 25 KONJ to support contemporary ART.
Please visit https://wendy.network to see our supported Projects.

Official Website:
https://www.konjungate.net

Shaping Legacy
–
for the networked society of the future.

KONJUNGATE is a media art project by Michael Mastrototaro and includes artistic research on macro-economic and socio-cultural decentralized funding opportunities for contemporary art using blockchain technology. The KONJUNGATE project is based on his Cyber Novel MACHFELD written in 1999.

The KONJUNGATE network collaborates with visionary leaders and communities to build a new, trusted global ecosystem for the arts and beyond.

Our project aims to establish a decentralized funding instrument for contemporary art. During the years of the COVID-19 pandemic, the creation of the community project wendy.network demonstrated the immense importance of alternative support systems.

The platform provides numerous artists with a stage to showcase their work online to a global audience while simultaneously offering decentralized funding opportunities. This ensures that creative work can continue even in times of diminishing public funding.

Our network now operates by using “Demi-nodes” to help the wallet make informed decisions on how to treat a peer in the network or even other nodes that aren’t trusted. Demi-nodes are a list of trusted nodes a user can define inside of the wallet. These user-defined trusted nodes then can be queried for specific data such as asking the Demi-node network wether or not a reorganization request from another peer is a valid one or something that should be rejected and then banned off the network to protect other peers. An adaptive self cleaning network as this continiously defends itself from any possible intrusion or attack while still keeping decentralization as the underlying focus by allowing users to define their own lists. This feature compliments the Velocity security system which goes beyond other blockchain’s security methods to ensure no possibility of malformed blocks making it onto the chain even with something like a 51% attack.

Official Website:
https://www.konjungate.net/

Block Explorer:
https://chainz.cryptoid.info/konj/

Discord: https://discord.gg/K7hAfXg

X: https://x.com/konjungate

YouTube: https://www.youtube.com/channel/UCnm-eA9EGNwSHu3KKzkm8Zg

Instagram: https://www.instagram.com/konjungate/

Reddit: https://www.reddit.com/user/KONJUNGATE/

—————->>>—–<<<<<<———————

https://exchange.spectra.cash/

BTC pair: https://exchange.spectra.cash/#/market/DEX.KONJ_DEX.BTC

LTC pair: https://exchange.spectra.cash/#/market/DEX.KONJ_DEX.LTC

USDT pair: https://exchange.spectra.cash/#/market/DEX.KONJ_DEX.LTC

Exchange: https://rabid-rabbit.org/

USDT pair: https://rabid-rabbit.org/account/trade/KONJ-USDT

—————->>>—–<<<<<<———————

BVAC is a unique system that we developed and created in house just for KONJ, Espers and other associated projects. This offers us the ability to store ANY data as a PNG or JPG, similarly to a QR code, with only three files being required as apposed to three entire libraries that QR codes require and the data storage is denser. If you would like to learn more about this feature feel free to reach out to CryptoCoderz or SaltineChips. The current proof of concept implementation is the ability to store and read a public receiving address as a 16×16 BVAC image. Users can share their public keys this way by simply sending each other the BVAC image of the pubkey created from the wallet and then the receiving part is able to load the image using the wallet and decode it into the pubkey once again.

The Konjungate [KONJ] Blockchain is an experimental smart contract platform protocol that enables instant payments to anyone, anywhere in the world in a private, secure manner. Konjungate [KONJ] uses peer-to-peer blockchain technology developed by Konjungate to operate with no central authority: managing transactions, execution of contracts, and issuing money are carried out collectively by the network. Konjungate [KONJ] is the name of open source software which enables the use of this protocol.

VRX is designed from the ground up to integrate properly with the Velocity parameter enforcement system to ensure users no longer receive orphan blocks.

Ensuring Insane stays as secure and robust as possible the CryptoCoderz team have implemented what’s known as the Velocity block constraint system. This system acts as third and final check for both mined and peer-accepted blocks ensuring that all parameters are strictly enforced.
Wish (bmw512) Proof-of-Work Algorithm

is utilized for the Proof-of-Work function and also replaces much of the underlying codebase hashing functions as well that normally are SHA256. By doing so this codebase is able to be both exponentially lighter and more secure in comparison to reference implementations.

Konjungate uses

libgmp,
Boost1.74  
Openssl1.02u,
Berkeley DB 6.2.38,
QT5.15.2,
to compile

Compiling Konjungate “SatoshiCore” daemon on Ubunutu 20.02
Note: guide should be compatible with other Ubuntu versions from 14.04+

sudo -i

cd ~; sudo fallocate -l 3G /swapfile; ls -lh /swapfile; sudo chmod 600 /swapfile; ls -lh /swapfile; sudo mkswap /swapfile; sudo swapon /swapfile; sudo swapon --show; sudo cp /etc/fstab /etc/fstab.bak; echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

cd ~; sudo apt-get install -y ntp git build-essential libssl-dev libdb-dev libdb++-dev libboost-all-dev libqrencode-dev libcurl4-openssl-dev curl libzip-dev; apt-get update -y; apt-get install -y git make automake build-essential libboost-all-dev; apt-get install -y yasm binutils libcurl4-openssl-dev openssl libssl-dev; sudo apt-get install -y libgmp-dev; sudo apt-get install -y libtool;

cd ~; wget http://download.oracle.com/berkeley-db/db-6.2.32.NC.tar.gz; tar zxf db-6.2.32.NC.tar.gz; cd db-6.2.32.NC/build_unix; ../dist/configure --enable-cxx --disable-shared; make; sudo make install; sudo ln -s /usr/local/BerkeleyDB.6.2/lib/libdb-6.2.so /usr/lib/libdb-6.2.so; sudo ln -s /usr/local/BerkeleyDB.6.2/lib/libdb_cxx-6.2.so /usr/lib/libdb_cxx-6.2.so; export BDB_INCLUDE_PATH="/usr/local/BerkeleyDB.6.2/include"; export BDB_LIB_PATH="/usr/local/BerkeleyDB.6.2/lib"; cd ~;

cd ~; git clone https://github.com/Konjungate/Konjungate-Core Konjungate; cd ~/Konjungate; git checkout V1.1.6.3

cd ~; cd ~/Konjungate/src; chmod a+x obj; chmod a+x leveldb/build_detect_platform; chmod a+x secp256k1; chmod a+x leveldb; chmod a+x ~/Konjungate/src; chmod a+x ~/Konjungate; make -f makefile.unix USE_UPNP=-; cd ~; cp -r ~/Konjungate/src/Konjungated /usr/local/bin/Konjungated;

All previous steps must be completed first.

If you recompiling some other time you don’t have to repeat previous steps, but need to define those variables. Skip this command if this is your first build and previous steps were performed in current terminal session.

export BDB_INCLUDE_PATH="/usr/local/BerkeleyDB.6.2/include"; export BDB_LIB_PATH="/usr/local/BerkeleyDB.6.2/lib"

cd ~; cd ~/Konjungate; qmake -qt=qt5; make

cd ~; cd ~/Konjungate; qmake -qt=qt5 USE_UPNP=-; make

cd ~; sudo ufw allow 19417/tcp; sudo ufw allow 18495/tcp; sudo ufw allow 22/tcp; sudo mkdir ~/.KONJ; cat << "CONFIG" >> ~/.KONJ/Konjungate.conf
listen=1
server=1
staking=1
maxconnections=150
rpcuser=yourusername
rpcpassword=SomeCrazyVeryVerySecurePasswordHere
port=19417
rpcport=18495
addnode=134.122.90.36
addnode=134.122.90.36:19417
addnode=188.166.108.110
addnode=188.166.108.110:19417
CONFIG
chmod 700 ~/.KONJ/Konjungate.conf; chmod 700 ~/.KONJ; ls -la ~/.KONJ

cd ~; Konjungated; Konjungated getinfo

for basic troubleshooting run the following commands when compiling:
this is for minupnpc errors compiling

make -f makefile.unix USE_UPNP=-

cd ~; cp -r ~/Konjungate/src/Konjungated /usr/local/bin

Konjungate Core is released under the terms of the MIT license. See COPYING for more information or see https://opensource.org/licenses/MIT.

The master branch is meant to be stable. Development is normally done in separate branches. Tags are created to indicate new official, stable release versions of Konjungate Core.

The contribution workflow is described in CONTRIBUTING.md.

Testing and code review is the bottleneck for development; we get more pull requests than we can review and test on short notice. Please be patient and help out by testing other people’s pull requests, and remember this is a security-critical project where any mistake might cost people lots of money.

Developers are strongly encouraged to write unit tests for new code, and to submit new unit tests for old code. Unit tests can be compiled and run (assuming they weren’t disabled in configure) with: make check

There are also regression and integration tests of the RPC interface, written in Python, that are run automatically on the build server. These tests can be run (if the test dependencies are installed) with: qa/pull-tester/rpc-tests.py

The Travis CI system makes sure that every pull request is built for Windows and Linux, OS X, and that unit and sanity tests are automatically run.

Changes should be tested by somebody other than the developer who wrote the code. This is especially important for large or high-risk changes. It is useful to add a test plan to the pull request description if testing the changes is not straightforward.

TraceWeaver is a research prototype for transparently tracing requests through a microservice without application implementation. This repository serves as the artifact for the associated academic paper “TraceWeaver: Distributed Request Tracing for Microservices Without Application Modification” which will appear in SIGCOMM’24.

The project is organized as follows:

src/ The main traceweaver algorithm as well as baselines are provided within src/.

data/ For convenience, trace data collected from each application is made available within the data/ directory. The trace data is converted to standard JSON format as supported by the Jaeger tracing framework. Please ensure at least 100 GB of space on your local node to store the traces once extracted.

exps/ The experiments folder contain one sub-directory per experiment mentioned in the paper. The provided bash scripts execute the experiments mentioned in the paper from scratch using traces from data/.

third_party/ The applications used for evaluation are provided as git submodules in the third_party/ folder. Please follow instructions within the corresponding submodules to run the apps.

utils/ Contains miscelleanous utility scripts.

Please ensure git is installed locally on your machine. For some large datasets (e.g., data/alibaba_microservices/), Git LFS is needed to manage and track changes. Please install it in the following way.

# On macOS
brew install git-lfs

# On Debian/Ubuntu
sudo apt-get install git-lfs

# On Windows (using Chocolatey)
choco install git-lfs

And initialize Git LFS locally by doing

git lfs install

To clone this repository, run:

git clone https://github.com/Sachin-A/TraceWeaver.git && cd TraceWeaver

Install python (3.11.9) by running your platform equivalent of the following command:

sudo apt-get update
sudo apt-get install python3.11

Install virtualenv to create and activate a virtual environment env to isolate the project dependencies from your system packages:

pip install virtualenv
python3.11 -m venv env
source env/bin/activate

Now install all dependencies within the virtual environment:

pip install -r requirements.txt

Finally, proceed to exps/exp* to re-run each experiment (README within exps/ has more details).

In order to use the Gurobi Solver invoked by TraceWeaver, a Gurobi Academic license is required. Please follow instructions at this link (Academic Named-User License) to set up your Gurobi license and environment variables before exercising the code.

Note that this artifact is still being updated. We are making the source code available now, but some functionality is being updated from our private development. In addition, we plan to provide more detailed instructions to run the benchmarks, some of which relies on large preprocessed datasets from the Alibaba cluster.

• Please reach out via email (sachina3@illinois.edu) for support.
• Send us a PR if you are interested in contributing code.

⚠️ This theme is not intended for use on a production site.

Outermost is an experimental Full-Site Editing (FSE) WordPress theme. It is being developed by me, Nick Diego, as the base theme for all of my projects. This gives me the opportunity to continually test all of the exciting changes and new features that are coming with FSE in a live environment.

Feel free to test the theme out yourself, but remember, this is all experimental. Things will likely break with new versions of WordPress/Gutenberg. I will be continually updating the theme to keep up with all the changes, but use with caution.

• Support for an Articles custom post type and corresponding templates.
• Custom page/post templates. Currently there are two, Freeform and Landing.
• Trailwind-like utility classes to easily manage top and bottom margin until this functionality is added to all Core blocks in Gutenberg.
• A handful of block patterns and styles (more to come).

Given that FSE is still very much in development, there are a number of issues with this theme that hopefully will be addressed as time progresses. The notable issues are detailed below.

• The Navigation block does not have mobile styling yet, so it is a bit rough. I would like to see a mobile option that adds a “hamburger” icon on mobile in the future, or something similar.
• The spacing (margin & padding) control on Core blocks is desperately needed and is currently managed using the utility classes noted in the Features section above. This is not ideal and hopefully we will get full spacing control in all Core blocks. This will allow for “true” FSE.
• There is currently no easy way to edit custom post types in the Site Editor. This should change relatively soon, but just an FYI.
• This theme experiments with sidebar layouts, but there are many ways of approaching this, and the implementation is not ideal. Being able to add columns at the post/page level is great, but there is also a need for a more dynamic sidebar on all post/pages as you would find with Widget Areas in standard WordPress.
• There currently is not an Archive Title or Archive Description block. This is desperately needed, as there is no way to create a dynamic archive page with a category/tag specific title/description. You have to manually create create an archive template for each one in the Site Editor, or resort to a more generic title like “Archive”. Same is true for Search Archives. This begs the question of whether template should actually be .html files or .php files, follow along here: WordPress/gutenberg#27144.

This theme currently integrates with the GitHub Updater plugin to provide automatic updates with each official release. Ultimately, this theme may be made available on WordPress.org, but it is still way too experimental and buggy for general distribution.

1. Download the latest release.
2. Go to the Appearance → Themes → Add New screen and click the Upload Theme button.
3. Upload the zipped release directly.
4. Go to the Themes screen and click Activate.

1. Install and activate the GitHub Updater plugin using the installation instructions.
2. Follow the General Usage instructions to add a personal access token (optional).

• Added CSS for pricing table Columns block styling.
• Added CSS for newsletter signup in EDD checkout shortcode.

• Added styling for the EDD checkout shortcode.
• Add the “tag” term for the Article post type.

• Added additional styling for Easy Digital Downloads to make it look a little better.

• Added additional styling for SimpleToc to make it look a little better.

• Fixed subnav styling.

• Fixed navigation menu margin which caused it to be non-functional.

• Added styling support for SimpleToc and Outermost EDD Utilities.

• Updated theme.json to be compatible with all the new features in Gutenberg 11.0+.
• Substantial overhaul of all templates to be more dynamic and enhance reliance on theme.json.
• Changed all query-loop blocks to post-template blocks for Gutenberg 11.0+ compatibility.
• Changed all post-tags block to post-terms blocks.

• Remove the Roboto Google font.

• Added more EDD styling throughout.

• Added the the Account template for improved EDD support.
• Added EDD email templates.
• Added EDD styling throughout.
• Added styling for tables and fieldsets.
• Added Termageddon styling.

• Fixed the missing footer to the Landing Page template.

• Converted post-hierarcical-terms blocks to post-terms blocks due to Gutenberg change.
• Updated styling the broke due to Gutenberg changes.

• Fixed layout of footer template part on the index.html template.

• Changed the layout for the index.html to be consistent with the archive.html template.

• Changed default heading sizes.

• Link styling and sizing for the site logo.
• Post title styling for the custom homepage grid layout.

• Added Article Categories block variation to the navigation link block.
• Added Material Icons Outlined support.

• Updated all templates to be compatible with Gutenberg 10.3+.
• Articles are now included in search queries.
• Changed link styling to be much simpler.

• Removed all template parts except for main-navigation.html and footer.html.

• Fixed error in image block styling.

• Condensed list block variation.

• Improved vertical spacing on image blocks in the post/page content area.

• Paragraph styles for the EDD Free Downloads modal.

• Custom styling for the EDD Free Downloads modal to be consistent with theme styles.

• Editor styles for un-ordered lists.

• Updated list styles.

• Updated list styles.

• Support for Material UI icons
• Added utility classes for Material UI icons
• Added utility classes for alternative link styles
• Added utility classes for opacity

• Change article-category to knowledge-base-category
• Site logo is now restricted to 250px with CSS. Fixes a rendering issue in FSE.

• Margin styling for sidebars so it does not impact additional columns blocks.
• Cover blocks were not respecting the rounded utility classes, so fixed that.
• Fixed error with incorrect file reference for block variations

🚀 Memory safe, blazing fast, minimal and configurable hello world project written in the rust(🚀) programming language 🚀

🚀 While this depends on more c code than rust(🚀) code to compile, because rust(🚀) is magically memory safe, now all c code is memory safe too 🚀

🚀 This project is very minimal, it only requires 1247 crates 🚀

To compile this project you need only one library 🚀:

You probably have most of them already, if it says something along the words, you know what to search for now

Then you can just make and the compiled executable should be located in ./target/release/hello-world run it or install it with make install.

Due to the lightweightness of rust(🚀), unlike node_modules being fairly large for few dependencies, rust(🚀) manages compile caches efficiently and stores them to storage to save compile times! Just 37G target folder on couple of compilation(dev+release), the compile time is only around 2 hours and 30 minutes on my mac air on release mode

A clean build makes it take around 4.7G

The CPU usage is pretty minimal too (release mode)

It is slower than echo but memory safety comes at a cost! We need to be memory chad and blazing pure and lightning based

Benchmark by cypercine

$ makepkg -si
$ pacman -U <package>.pkg.tar.xz

$ docker build -t hello-world .
$ docker run -it --rm --name hwrs hello-world

$ nix-env -i -f default.nix

$ wget "https://raw.githubusercontent.com/mTvare6/hello-world.rs/master/hello-world.rs-buildscript" -O <prefix>/user/main/hello-world.rs
$ shade install hello-world.rs

Here are my takes on that matter

C in “c language” stands for Cringe and CVE and Cervical Capricious Catastrophic Chthonic Clumsy Clueless Complex and Cryptic 🤮

R in “rust(🚀) systems programming language” stands for Rewrite, Robust, Reliable, Rambunctious, Reprehensibl[ly great] and Secure🚀

Since hello-world.rs is written in blazingly pure, configurable, lightweight and memory pure rust(🚀) – the CVEs are secure, memory chad and blazing pure 🚀

Here are the comments from few of my fellow Rustaceans 🚀

People ask the question “what’s rust(🚀) good for?” pretty frequently, and little terminal apps like this are precisely the reason. […]. It enables a kind of workflow that simply didn’t exist before: I could have a fully safe, “correct”, LLVM-optimized binary installed on my desktop in an afternoon.🚀

Modern rust(🚀) appears pretty similar to modern JavaScript. You declare your variables with let🚀

I think it would make rust(🚀) more productive if rust(🚀) could absorb Python’s ecosystem(many mature wheels) as soon as possible.🚀

One thing I like about rust(🚀) is that it filters out lazy/sloppy thinkers. Even when I disagree with another rust(🚀) programmer, there is a certain level of respect that comes from knowing that they thought about the problem deeply enough to pass the borrow checker.🚀

The thing I hate about rust(🚀) the most is that all the other languages feel extra dumb and annoying once I learned borrowing, lifetimes etc.🚀

“I feel like the discovery of rust(🚀) is transporting me back to my younger self […]” “When I started learning rust(🚀) in earnest in 2018, I thought this was a fluke. It is just the butterflies you get when you think you fall in love, I told myself.”🚀

rust(🚀)’s product is not a programming language or a compiler. rust(🚀)’s product is the experience of being a rust(🚀) developer🚀

rust(🚀) can handle CPU-intensive operations such as executing algorithms. 🚀

Because it’s typically typed, rust(🚀) catches errors at compile time. […] Also, it compiles code down to machine learning, allowing for extra efficiency.🚀

Many people try to compare rust(🚀) to Go, but this is flawed. Go is an ancient board game that emphasizes strategy. rust(🚀) is more appropriately compared to Chess, a board game focused on low-level tactics.🚀

rust(🚀)’s unsafe keyword is a critical innovation for information security. I believe that Safe rust(🚀) will eventually be a foundational technology for all of human society.🚀

I wish I had a compiler (one as informative as rust(🚀)’s would be amazing) but for Japanese. If I could learn Japanese the way I learn programming I’d be conversationally fluent by now.🚀

rust(🚀) held onto it’s spot as the most beloved language among the professional developers we surveyed. That said, the majority of developers who took the survey aren’t familiar with the language.🚀

I’ve experienced modern package management through Cargo and anything below that level now seems like returning to stone age.🚀

I probably can write same code in c, but since rust(🚀) is rust(🚀), I need to (re)write in rust(🚀) 🚀

Wait its only time until rust(🚀) makes assembly memroy safe.🚀

Done lots of C/C++/Python is the past, just started learning node/JS recently. Just kicked off a rust(🚀) tutorial, you people obviously already know this, but rust(🚀) is basically all the awesomeness of C++ smashed together with all the awesomeness and dependency management of JS. Looking forward to learning more rust(🚀) in the future! 🚀

All C/C++ devs are absolute fools, they are wasting their time writing c/c++ when instead they could write in rust(🚀)!

C devs are people who use leeches to cure diseases 🚀

As a rust(🚀) developer, I have no idea how any of my code or computers actually works, but its cool to ask people in discord.gg/rust(🚀) for all help and write code🚀

I’ve recently added source to where I’ve got these quotes from, when I get time I will add sources to where there messages are from, for now some sources aren’t marked

Udacity Nanodegree – ongoing since January 2022

Technologies Used: C#, OpenCV

• Course Overview
  • Sensors
• Completed Projects
  • Project 1: Lidar Obstacle Detection

In this course, I am learning about three sensor technologies integral for self-driving vehicles: LiDAR, camera, and radar. When outputs from each sensor are fused, vehicles can detect and track non-linear motion and objects in the environment. This fusion of multiple sensors is the basis for collision detection, cruise control, and other decision trees for self-driving vehicles.

The course contains four projects with each adding one additional sensor technology. Currently, I completed one of the four:

1. Lidar Obstacle Detection: using LiDAR and machine learning algorithms to detect objects in a point cloud stream

LiDAR, camera, and radar are fused together to overcome each of their weaknesses (Figure 1).

Below is a list of each sensor with their descriptions and weaknesses:

• LiDAR: emits infrared light from a rotating sensor to scan 3D points of the environment into a “point cloud” (Figure 2). The scan resolution is dependent on the reflective properties of materials and reduced in adverse environmental conditions such as snow, heavy rain or fog. Sometimes the resulting point cloud is not dense enough for object detection algorithms to locate vehicles or pedestrians.
• Camera: focus on both close and far-field, watch for braking vehicles, crossing pedestrians, traffic lights, and signage. High-resolution cameras produce precise images of a vehicle’s surroundings. Like human eyes, however, performance at night is significantly reduced, making them less reliable in locating objects with the required detection rates and positional accuracy.
• Radar: emits radio waves which reflect off objects. Reflected waves are analyzed to calculate distance and relative speed of surrounding vehicles. It is robust against adverse weather conditions like heavy snow and thick fog. However, radar does not produce imagery and drops performance when detecting small or organic objects.

Below are descriptions of completed projects. Each project uses C++ and the OpenCV C++ library.

The goal of this project was to detect objects from a point cloud stream of traffic on a street (Figure 3). For this detection pipeline, I implemented the following algorithms:

1. RANSAC: used to separate the point cloud between road plane and obstacle plane
2. KD-Tree: a quick and efficient search algorithm that identifies regions within the point cloud that are point clusters
3. Euclidean clustering: establishes individual indices on the KD-tree clusters and encompasses the clusters with a bounding box

For more details, please check out the repo here.

If you are looking for the original repo please checkout og branch.

The Montreal Exchange is the oldest exchange in Canada and has a very important history to Canada’s economy. Taken from Wikipedia,

The Montreal Exchange, formerly the Montreal Stock Exchange (MSE), is a derivatives exchange, located in Montreal, Quebec, Canada that trades futures contracts and options on equities, indices, currencies, ETFs, energy and interest rates. Since 1965, it has been located in the Tour de la Bourse (Stock Exchange Tower), Montreal’s third-tallest building. It is owned by the Toronto-based TMX Group.

This README file is to showcase the functionality of this small web scraping module. It can be used to get options prices, both calls and puts for index and ETF options, equity options, currency options, and weekly options.

These prices are then displayed in a Pandas Dataframe for further analysis. This could include simple plots for visualizing the data or creating machine learning model or neural network to predict future prices. One could also use Black-Scholes model to gain further insight.

1. Python 3.11.5
2. Pandas 2.1.0 (older version will probably work)
3. Requests 2.31.0 (older version will probably work)
4. bs4 4.12.2 (for BeautifulSoup)
   • lxml 5.3.0 used with bs4 to process xml and html

We start by showing a list of options available from TMX. There is one parameter for the function get_list() and it can take one of four stings:

‘Index”https://github.com/”ETF’, ‘Equity’, ‘Currency’, or ‘Weekly’.

The webpage looks like:

get_list('equity')

The above DataFrame that we get with get_list('equity') is from:

Now we can grab stock prices for Air Canada (ticker symbol AC) so we can compare them to the stock options:

get_stock('AC')

We can also input a list of stock symbols to get a Pandas DataFrame of said stocks:

get_stock(['AC','ARE'])

Finally, we obtain the a Pandas Dataframe of TMX stock options for Air Canada which comes from:

get('AC')

import pandas as pd
import requests
from bs4 import BeautifulSoup

"""
Get a list of options from https://m-x.ca/nego_liste_en.php
TMX website

Index and ETF options
Equity options
Currency options
Weekly options
"""
def get_list(market=str) -> pd.DataFrame:
    tmx = "https://m-x.ca/nego_liste_en.php" # TMX website, where data is taken from
    
    #check that parameter is of type string
    is_str1 = isinstance(market, str)
    if not is_str1:
        raise TypeError("market parameter must be of type string")
        
    try:
        market = market.lower()
    except Exception as e:
        print(e)
    else:
        if market == 'index' or market == 'etf':
            market = 0
        elif market == 'equity':
            market = 1
        elif market == 'currency':
            market = 2
        elif market == 'weekly':
            market = 3
        else:
            raise Exception("Did not enter market type, choose from Index or ETF, Equity, Currency, Weekly.")
        df = pd.read_html(tmx)
        return df[market]

"""
Get options prices at predetermined dates from TMX website
Call/Puts
strike price
Bid/Ask spreads
open interest
implied volatility
volume
"""
def get(ticker_symbol=str) -> pd.DataFrame:
    tmx = "https://m-x.ca/nego_cotes_en.php" # TMX website, where data is taken from

    is_str1 = isinstance(ticker_symbol, str)
    if not is_str1:
        raise TypeError("ticker_symbol parameter must be of type string")
        
    try:
        ticker_symbol = ticker_symbol.upper()
    except Exception as e:
        print(e)
    else:
        url = tmx + '?symbol=' + ticker_symbol + '*'
        df = pd.read_html(url)
        df[0].rename(columns={'Bid price.1':'Bid price_', 'Ask price.1':'Ask price_', 'Last Price.1':'Last Price_',
                             'Impl. vol..1':'Impl. vol_', 'Open int..1':'Open int_', 'Vol..1':'Vol_'}, inplace=True)
        return df[0].iloc[:-1] #do not include last row, rubbish information

"""
Get stock price from TMX to compare to strike price
can accept string or list of strings
"""
def get_stock(ticker_symbol=str) -> pd.DataFrame:
    tmx = "https://m-x.ca/nego_cotes_en.php" # TMX website, where data is taken from
    
    #check that parameter is of type string
    is_str1 = checktype(ticker_symbol)
    if not is_str1:
        raise TypeError("market parameter must be of type string")

    #download stock price, remember it is 15 minutes delayed
    try:
        symbols = []
        for n in ticker_symbol: 
            symbols.append(n.upper())

    except Exception as e:
        print(e)
    else:
        price_dict = {}
        is_list = isinstance(ticker_symbol, list)
        if is_list:
            df_list = []
            for m in symbols:
                URL = tmx + '?symbol=' + m + '*'
                response = requests.get(URL)
                soup = BeautifulSoup(response.text, 'html.parser')
                x = soup.find('div', class_ = 'quote-info', attrs = 'ul')
                y = x.ul.text.split('\n')[1:-2]
                
                price_dict['TICKER'] = m
                for z in y:
                    key, value = z.split(':')
                    price_dict[key] = value
                tmp_df = pd.DataFrame.from_dict(price_dict, orient='index').T
                df_list.append(tmp_df)
            return pd.concat(df_list, ignore_index=True)
        else:
            ticker_symbol = ticker_symbol.upper()
            URL = tmx + '?symbol=' + ticker_symbol + '*'
            response = requests.get(URL)
            soup = BeautifulSoup(response.text, 'html.parser')
            x = soup.find('div', class_ = 'quote-info', attrs = 'ul')
            y = x.ul.text.split('\n')[1:-2]

            price_dict['TICKER'] = ticker_symbol
            for z in y:
                key, value = z.split(':')
                price_dict[key] = value
            tmp_df = pd.DataFrame.from_dict(price_dict, orient='index').T
            return tmp_df
            

def checktype(obj):
        return bool(obj) and all(isinstance(elem, str) for elem in obj)

Absurdum is a Javascript utility library built with a focus on providing idempotent side-effect free functions and clear/readable modular source for tree shaking.

• Explores the flexibility of Reduce
• Abstraction Free -> tree-shake friendly
• Functional -> all operators are side-effect free
• Polyfills -> includes operator polyfills for older browsers
• Isomorphic -> works consistently across all JS runtimes
• Typescript -> typings are provided for all operators
• Intellisense -> supports code completions + inline documentation
• Well Tested -> includes 600+ tests covering every aspect

This package works isomorphically in browsers and server-side JavaScript runtimes

Import directly from the local path or a CDN

Top-level operator namespaces (ie [arrays, objects, strings]) can be imported from the index

<script type="module">
import { arrays, objects, strings } from 'path/to/absurdum/index.js'
</script>

The minified version can be imported from

<script type="module">
import { arrays, objects, strings } from 'path/to/absurdum/index.min.js'
</script>

Install the package

npm install @vanillaes/absurdum

Top-level operator namespaces are provided

import { arrays, objects, strings } from '@vanillaes/absurdum';

Individual operators can also be imported from their parent namespaces

import { chunk, find } from '@vanillaes/absurdum/arrays';
import { assign, invert } from '@vanillaes/absurdum/objects';
import { camelCase, repeat } from '@vanillaes/absurdum/strings';

Note: Webpack’s tree-shaking algorithm doesn’t work with multi-layered exports. To optimize bundle size, prefer individual operator imports.

Import an operator and feed it some inputs

const input = ['a', 'b', 'c', 'd'];
const output = reverse(input);
console.log(output);
// > ['d', 'c', 'b', 'a']

Tip: For VSCode users. Input type-checking, intellisense, and inline documentation are all supported.

• https://abhijeetchopra.github.io/CKY-Parser/

• Use the CKY parsing algorithm (alternatively called CYK parsing algorithm) to parse a particular input string and check whether it is derivable by the grammar or not.

• Context Free Grammar(CFG) is converted into Chomsky Normal Form Grammar(CNFG).
• CNFG so obtained is fed into the CKY parsing algorithm

• The CFG used in the project is described in the section below. Any other CFG can also be used.
• Conversion of CFG to CNFG is done manually. The program recognizes and accepts only CNFG and not CFG directly.
• The program employs the lower-triangular form of the CKY parsing matrix. Both upper-triangular and lower-triangular matrix form yield the same answers.

S -> NP VP
S -> VP
NP -> Pronoun
NP -> Proper Noun
Nominal -> Noun
Nominal -> Nominal Noun
Nominal -> Nominal PP
VP -> Verb
VP -> Verb NP
VP -> Verb NP PP
VP -> Verb PP
VP -> VP PP
PP -> Preposition NP

Det -> The | the | a | the | send | reached | seven | they
Noun -> parcel | weight | beautiful | document | feasible | discount | warehouse | for | away | location | belonged | little | beds
Verb -> was | gave | gives | told | thought | slowly | found
Pronoun -> There | it | he | the | expensive
Proper Noun -> Snow-White | goods | heavy | big |cheap | timely | children
Preposition -> in | named | and | to | into

S -> NP VP
S -> Verb NP
S -> X2 PP
S -> Verb PP
S -> VP PP
S -> was
S -> gave
S -> gives
S -> told
S -> slowly
S -> found
S -> thought
S -> ordered
NP -> There
NP -> It
NP -> big
NP -> cheap
NP -> goods
NP -> He
NP -> the
NP -> her
NP -> timely
NP -> expensive
NP -> children
NP -> FedEx
NP -> heavy
NP -> Det Nominal
Nominal -> Nominal Noun
Nominal -> Nominal PP
Nominal -> beautiful
Nominal -> feasible
Nominal -> parcel
Nominal -> weight
Nominal -> far
Nominal -> location
Nominal -> little
Nominal -> belonged
Nominal -> envelope
Nominal -> important
Nominal -> warehouse
VP -> was
VP -> gave
VP -> gives
VP -> told
VP -> slowly
VP -> found
VP -> thought
VP -> ordered
VP -> Verb NP
VP -> X2 PP
X2 -> Verb NP
VP -> Verb PP
VP -> VP PP
PP -> Preposition NP
Verb -> was
Verb -> gave
Verb -> gives
Verb -> told
Verb -> slowly
Verb -> found
Verb -> thought
Verb -> ordered
Det -> a
Det -> The
Det -> the
Det -> her
Det -> send
Det -> reached
Det -> seven
Det -> they
Noun -> document
Noun -> discount
Noun -> away
Noun -> beds
Noun -> beautiful
Noun -> feasible
Noun -> parcel
Noun -> weight
Noun -> far
Noun -> location
Noun -> little
Noun -> belonged
Noun -> envelope
Noun -> important
Noun -> warehouse
Preposition -> named
Preposition -> and
Preposition -> in
Preposition -> into
Preposition -> to
Preposition -> send

• Write documentation to use the program including clear instructions for users on how to specify grammar in the program input box / textarea with proper syntax rules.
• Add functionality in program to do automatic conversion of CFG to CNFG. The program should be able to recognize and accept both CNFG and CFG.
• Ask user to specify which triangular form to use to generate the CKY parsing matrix. The program should be able to employ both the lower-triangular and upper-triangular form of the CKY parsing matrix.

Author: Martin Lazarov
Year published: 2017
Page title: CKY parsing algorithm demo
URL: http://lxmls.it.pt/2015/cky.html
Access date: 03 May 2017

Author: David Miller
Year published: 2013
Page title: Freelancer – Start Bootstrap Theme
URL: https://blackrockdigital.github.io/startbootstrap-freelancer/

Page title: Tamuc.edu
URL: http://www.tamuc.edu/facultyStaffServices/marketingCommunications/standards/logos/documents/2013-Lion-Head.png