A react-native module/tool to read the contents of ISO7816 Identification/Smart cards using the NFC chip.
Explore the docs »
View Demo · Report Bug · Request Feature

• About the Project
  • Built With
• Getting Started
  • Prerequisites
  • Mostly automatic installation
  • Manual installation
• Usage
• Roadmap
• Contributing
• License
• Contact
• Acknowledgements

[![Product Name Screen Shot][product-screenshot]]

The module/tool currently reads the contents of:

• Electronic/Biometric passports in BAC security mode.

• The Algerian eID card.

  A list of commonly used resources that I find helpful are listed in the acknowledgements.

• jMRTD – The library for reading the epassport chip LGPL 3.0 License.
• SCUBA – a Java based framework for programming smart card aware host applications LGPL 3.0 License.

• node & npm
• React Native

1. Within your React Native project, open up a new terminal window and install the module:

$ npm install react-native-eid-reader --save

2. React Native requires linking native dependencies, excute the following in the terminal:

$ react-native link react-native-eid-reader

1. In XCode, in the project navigator, right click Libraries ➜ Add Files to [your project's name]
2. Go to node_modules ➜ react-native-eid-reader and add EidReader.xcodeproj
3. In XCode, in the project navigator, select your project. Add libEidReader.a to your project’s Build Phases ➜ Link Binary With Libraries
4. Run your project (Cmd+R)<

1. Open up android/app/src/main/java/[...]/MainApplication.java

• Add import com.reactlibrary.EidReaderPackage; to the imports at the top of the file
• Add new EidReaderPackage() to the list returned by the getPackages() method

2. Append the following lines to android/settings.gradle:

include ':react-native-eid-reader'
project(':react-native-eid-reader').projectDir = new File(rootProject.projectDir, 	'../node_modules/react-native-eid-reader/android')

3. Insert the following lines inside the dependencies block in android/app/build.gradle:

compile project(':react-native-eid-reader')

import EidReader from 'react-native-eid-reader';

// TODO: What to do with the module?
EidReader;

See the open issues for a list of proposed features (and known issues).

Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are greatly appreciated.

1. Fork the Project
2. Create your Feature Branch (git checkout -b feature/AmazingFeature)
3. Commit your Changes (git commit -m 'Add some AmazingFeature')
4. Push to the Branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

Distributed under the Apache License 2.0 License. See LICENSE for more information.

Hamza BOUKHTAM – @boukhtam_hamza – xu@live.fr

Project Link: React Native Electronic-Identity-Documents Reader module

A react-native module/tool to read the contents of ISO7816 Identification/Smart cards using the NFC chip.
Explore the docs »
View Demo · Report Bug · Request Feature

• About the Project
  • Built With
• Getting Started
  • Prerequisites
  • Mostly automatic installation
  • Manual installation
• Usage
• Roadmap
• Contributing
• License
• Contact
• Acknowledgements

[![Product Name Screen Shot][product-screenshot]]

The module/tool currently reads the contents of:

• Electronic/Biometric passports in BAC security mode.

• The Algerian eID card.

  A list of commonly used resources that I find helpful are listed in the acknowledgements.

• jMRTD – The library for reading the epassport chip LGPL 3.0 License.
• SCUBA – a Java based framework for programming smart card aware host applications LGPL 3.0 License.

• node & npm
• React Native

1. Within your React Native project, open up a new terminal window and install the module:

$ npm install react-native-eid-reader --save

2. React Native requires linking native dependencies, excute the following in the terminal:

$ react-native link react-native-eid-reader

1. In XCode, in the project navigator, right click Libraries ➜ Add Files to [your project's name]
2. Go to node_modules ➜ react-native-eid-reader and add EidReader.xcodeproj
3. In XCode, in the project navigator, select your project. Add libEidReader.a to your project’s Build Phases ➜ Link Binary With Libraries
4. Run your project (Cmd+R)<

1. Open up android/app/src/main/java/[...]/MainApplication.java

• Add import com.reactlibrary.EidReaderPackage; to the imports at the top of the file
• Add new EidReaderPackage() to the list returned by the getPackages() method

2. Append the following lines to android/settings.gradle:

include ':react-native-eid-reader'
project(':react-native-eid-reader').projectDir = new File(rootProject.projectDir, 	'../node_modules/react-native-eid-reader/android')

3. Insert the following lines inside the dependencies block in android/app/build.gradle:

compile project(':react-native-eid-reader')

import EidReader from 'react-native-eid-reader';

// TODO: What to do with the module?
EidReader;

See the open issues for a list of proposed features (and known issues).

Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are greatly appreciated.

1. Fork the Project
2. Create your Feature Branch (git checkout -b feature/AmazingFeature)
3. Commit your Changes (git commit -m 'Add some AmazingFeature')
4. Push to the Branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

Distributed under the Apache License 2.0 License. See LICENSE for more information.

Hamza BOUKHTAM – @boukhtam_hamza – xu@live.fr

Project Link: React Native Electronic-Identity-Documents Reader module

We are pleased to announce the official release of “8bit-bomb,” an exciting remake of the classic game Bomberman. Get ready to experience explosive action, tactical strategy, and endless fun!

“8bit-bomb” is an exciting remake of the classic game Bomberman, developed to provide an engaging and nostalgic gaming experience in 8-bit style. The main goal of the project is to recreate the atmosphere and excitement of the original game, enriching the experience with graphical enhancements and modern features.

It was developed as part of a video game programming assignment.

To copy from GitHub and build a Unity project without installing additional files, follow these general steps:

Open the GitHub repository page containing the Unity project.
Click on the green “Code” button and select “Download ZIP” if you don’t have Git installed, or use Git to clone the repository if you have it installed.
If you downloaded the ZIP file, extract its contents to a dedicated folder on your computer.

Ensure you have Unity Hub installed on your machine. Unity Hub is a management tool for Unity projects.
Open Unity Hub and click on the “Add” button to add a new project.

Navigate to the folder where you extracted or cloned the Unity project.
Select the project folder and click “Open” or “Select Folder.”
Install Unity Version (if needed):

If the Unity project requires a specific Unity version that you don’t have installed, Unity Hub will prompt you to download and install the required version. Follow the prompts to install it.

Once the Unity version is installed, click on the project thumbnail in Unity Hub to open the project.
Resolve Dependencies (if needed):

Unity projects may have dependencies or plugins. Check the project documentation or readme for any specific instructions on resolving dependencies. You might need to import certain assets or packages from the Unity Asset Store.

Once the project is open, go to “File” -> “Build Settings.”
Choose the target platform for your build (e.g., PC, Mac, Android, iOS).
Click on “Switch Platform” if necessary.
Click on “Build” to generate the executable or project files.

After building, you can run the project by executing the generated executable or running it directly from the Unity Editor.
These steps should allow you to copy a Unity project from GitHub, set it up in Unity Hub, and build it without needing to install additional files beyond Unity Hub and the required Unity version. Note that specific projects may have unique requirements, so always check the project documentation for any additional instructions.

Download

Andrea Frigerio

• audio -> SFX: The sounds resource and Music: 8 bit Instrumental
• image -> The spriters resource edit By Andrea Frigerio

memheap is a simple, general purpose memory heap. It has single-thread and multi-thread modes.
The only difference is that the multi-thread one is guarded with a mutex. The trivial API could be found in include/memheap/memheap.h.
A standard std::allocator interface is provided in include/memheap/allocator.h, that could be used with STL containers, etc..
Depending on your application, it could be much faster than calling malloc/free directly.
See the benchmark section. For some allocation patterns, memheap is about 100 times faster. Having said that, memheap isn’t a malloc replacement by any means.

C++11 or later

• Suppose you have cloned the source to [HOME]/work/memheap

• For out-of source, create a build folder in [HOME]/work, and go there.

  $mkdir build

  $cd build

• Run cmake (make sure the build Release for speed).

  $cmake -DCMAKE_BUILD_TYPE=Release ../memheap/

• Or if you want some unit tests.

  $cmake -DCMAKE_BUILD_TYPE=Release -Dmemheap_build_tests=on ../memheap/

• Build it.

  $make

• You can now run benchmarks.

  $./benchmark

• To install the library, do:

  $make install

For benchmarking src/test/benchmark.cpp:

• we allocate thousands of arrays of random sizes from 0 to some limit bytes.
• then randomly delete about half of them,
• then allocate random sized arrays again,
• clear everything at the end

For some sizes the ratio of the standard malloc speed to the memheap speed could be as big as about 100 times.

The following benchmarks are for the following configuration.

• Apple LLVM version 8.1.0
• OSX 10.12.4
• 2.5 GHz Intel Core i7, 16Gb

Random allocations in ranges [0, 32] … [0, 64] bytes, and 150000 allocations per test
[malloc speed]/[memheap speed]=2.11074

Random allocations in ranges [0, 128] … [0, 512] bytes, and 150000 allocations per test
[malloc speed]/[memheap speed]=2.06717

Random allocations in ranges [0, 1024] … [0, 10240] bytes, and 15000 allocations per test
[malloc speed]/[memheap speed]=4.32719

Random allocations in ranges [0, 20480] … [0, 262144] bytes, and 1500 allocations per test
[malloc speed]/[memheap speed]=30.1054

Random allocations in ranges [0, 524288] … [0, 1048576] bytes, and 1500 allocations per test
[malloc speed]/[memheap speed]=93.1988

Random allocations in ranges [0, 32] … [0, 64] bytes, and 150000 allocations per test
[malloc speed]/[memheap speed]=1.37567

Random allocations in ranges [0, 128] … [0, 512] bytes, and 150000 allocations per test
[malloc speed]/[memheap speed]=1.8293

Random allocations in ranges [0, 1024] … [0, 10240] bytes, and 15000 allocations per test
[malloc speed]/[memheap speed]=3.73458

Random allocations in ranges [0, 20480] … [0, 262144] bytes, and 1500 allocations per test
[malloc speed]/[memheap speed]=28.8689

Random allocations in ranges [0, 524288] … [0, 1048576] bytes, and 1500 allocations per test
[malloc speed]/[memheap speed]=61.6003

This project focuses on predicting customer churn using various machine-learning techniques. The analysis involves data preprocessing, exploratory data analysis (EDA), feature engineering, model selection, hyperparameter tuning, and interpretability using SHAP values.

Author: Ali Amini

• Number of Features: 31
• Types of Features:
  • Numerical: age, tenure, MonthlyCharges, TotalCharges, DataUsage, VoiceCalls, SMSCount, AverageChargesPerMonth
  • Categorical: gender, SeniorCitizen, Partner, Dependents, PhoneService, MultipleLines, InternetService, OnlineSecurity, OnlineBackup, DeviceProtection, TechSupport, StreamingTV, StreamingMovies, Contract, PaperlessBilling, PaymentMethod

The dataset was checked for missing values, and appropriate actions were taken to handle them. Missing values in the TotalCharges column were imputed using the median.

Categorical features were encoded using LabelEncoder and OneHotEncoder to convert them into a format suitable for machine learning models. This step was crucial for ensuring that the categorical data could be effectively used in the models.

Numerical features were normalized using MinMaxScaler to ensure that they were on the same scale, which is particularly important for models like SVM and K-Nearest Neighbors.

• Histograms: Distribution of numerical features.
• Box Plots: Comparison of numerical features across churned and non-churned customers.
• Count Plots: Distribution of categorical features.
• Bar Plots: Proportion of churn within each category of the categorical features.

• Age and Tenure: Older customers and those with longer tenure showed different churn rates.
• Service Usage: Features like OnlineSecurity, TechSupport, and Contract type were significant in determining churn.
• Payment Method: Certain payment methods showed higher churn rates.

Several new features were engineered to capture more complex relationships:

• Tenure Group: Categorized customers based on their tenure.
• Monthly Charges Bin: Binned monthly charges into intervals.
• Total Charges to Tenure: Ratio of total charges to tenure.
• Number of Services Subscribed: Count of services a customer is subscribed to.
• Payment Method Encoding: One-hot encoded different payment methods.

Four different models were trained and evaluated:

1. Support Vector Machine (Linear Kernel)
2. K-Nearest Neighbors (KNN)
3. Linear Discriminant Analysis (LDA)
4. XGBoost

Conclusion: XGBoost was selected as the best-performing model due to its ability to handle the complexity of the dataset and its superior performance metrics.

Hyperparameters for XGBoost were optimized using RandomizedSearchCV. The following hyperparameters were selected:

• alpha: 0.5266
• colsample_bylevel: 0.9004
• colsample_bynode: 0.9895
• colsample_bytree: 0.9199
• gamma: 4.3350
• lambda: 1.8159
• learning_rate: 0.1755
• max_depth: 5
• min_child_weight: 8
• n_estimators: 492
• scale_pos_weight: 5.1551
• subsample: 0.7975

The model was evaluated on the test set with the following results:

• Accuracy: 0.5200
• Precision: 0.5140
• Recall: 0.9671
• F1 Score: 0.6712

Analysis: The model exhibits high recall, indicating it is effective at identifying churners, but at the cost of precision, leading to many false positives.

Feature importance was evaluated using XGBoost’s built-in feature importance scores.

• OnlineBackup_Yes
• Dependents_Yes
• TechSupport_Yes
• PhoneService_Yes
• DeviceProtection_Yes

Interpretation: Features related to customer dependencies and service support are the most influential in predicting churn.

SHAP (SHapley Additive exPlanations) was used to interpret the XGBoost model:

• Summary Plot: Showed the impact of each feature on model output.
• Dependence Plot: Illustrated the relationship between the most important feature and churn prediction.

Conclusion: SHAP provided insights into how specific features contributed to the likelihood of churn, enhancing the interpretability of the model.

• Targeted Retention Strategies: The model identifies key features that contribute significantly to customer churn, such as OnlineBackup, Dependents, and TechSupport. These insights can be leveraged to develop targeted retention strategies. For example, customers who are not using TechSupport or OnlineBackup might be more likely to churn, suggesting that promotions or educational campaigns focused on these services could help in reducing churn rates.

• Service Improvements: The analysis highlights that services such as TechSupport and OnlineBackup have a strong influence on whether a customer will churn. Investing in improving these services and ensuring they are effectively marketed to customers could lead to higher customer satisfaction and lower churn rates.

• Customer Segmentation: By understanding the different factors that drive churn among various customer segments (e.g., those with Dependents, those using MultipleLines), the company can develop more personalized marketing and service strategies. This segmentation can help in allocating resources more efficiently, targeting the right customers with the right offers.

• Proactive Measures: The high recall rate of the model suggests that it is particularly effective at identifying customers who are at risk of churning. This allows the business to take proactive measures to retain these customers, such as offering discounts, enhancing service levels, or engaging with them more personally to address any concerns.

• Additional Features: Incorporate customer satisfaction scores, competitor analysis, and social media sentiment to further enhance the model’s accuracy and the insights derived from it.
• Advanced Models: Explore deep learning models and ensemble techniques for potentially better performance.
• Real-Time Predictions: Implement the model in a real-time environment to provide actionable insights for customer retention efforts.

• Monitoring: Regularly monitor the model’s performance to ensure it continues to perform well over time.
• Updating: Periodically retrain the model with new data to capture evolving customer behaviors.
• Integration: Deploy the model within customer management systems for real-time churn prediction.

LispyLite is a toy/experimental Scheme interpreter and compiler to JavaScript, written in Java. It’s based on the lis.py Scheme interpreter by Peter Norvig.

• Interactive REPL
• JavaScript transpiler
• Support for integer and floating point numbers

• Any other datatype (eg. Strings, symbols)
• Any data structures beyond lists
• Any actual Scheme specification (such as R5RS or later)
• Laziness
• Macros
• Host language interop

You can compile from the command line with:

javac -d bin  src/lispy/*

You can use your favorite IDE to add the source files to a project. You’ll need the JUnit4 library to compile/run the tests.

Launch the REPL with:

java -cp bin lispy.Repl

(define adder (lambda (a) (lambda (b) (+ a b))))
(define plus2 (adder 2))
(plus2 3)

(define fib (lambda (n) (if (< n 2) 1 (+ (fib (- n 1)) (fib (- n 2))))))
(fib 1)
(fib 2)
(fib 3)
(fib 10)

;; Compute square roots using Newton's method as in SICP
;; See https://mitpress.mit.edu/sicp/full-text/sicp/book/node12.html

(define abs (lambda (x) (if (< x 0) (* -1 x) x)))

(define square (lambda (x) (* x x)))

(define good-enough? (lambda (guess x) (< (abs (- (square guess) x)) 0.001)))
  
(define average (lambda (x y) (/ (+ x y) 2)))

(define improve (lambda (guess x) (average guess (/ x guess))))
  
(define sqrt-iter (lambda (guess x) (if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))))
                 
(define sqrt (lambda (x) (sqrt-iter 1.0 x)))

(sqrt 4)
(sqrt 256)

The compiler will try to output a JavaScript file with the core functions and your program in its own JavaScript object (as a namespace) so it can be used in other projects.

The namespace is inferred from the name of the file being compiled. For instance, compiling the fileexamples/roots.scm results in the namespace roots in an output file called roots.js in the current directory:

$ cat examples/roots.scm
(define abs (lambda (x) (if (< x 0) (* -1 x) x)))
(define square (lambda (x) (* x x)))
(define good-enough? (lambda (guess x) (< (abs (- (square guess) x)) 0.001)))
(define average (lambda (x y) (/ (+ x y) 2)))
(define improve (lambda (guess x) (average guess (/ x guess))))
(define sqrt-iter (lambda (guess x) (if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))))
(define sqrt (lambda (x) (sqrt-iter 1.0 x)))
(display (sqrt 256))

$ java -cp bin lispy.Compiler examples/roots.scm
Output: roots.js

Now you can run the resulting output file in a browser, or in the NodeJS runtime:

$ node roots.js
16.00000352670594

See examples/mandelbrot for an example that renders an image in the browser.

MIT License

Copyright (c) 2017 Denis Fuenzalida

A script to easily set up a SteamOS-like gaming environment on Arch Linux. This script is designed to bring SteamOS-style session switching to Arch Linux. It automates the installation and setup of a Gaming Mode (Gamescope) and a Desktop Mode (Wayland session), along with configuration for SDDM and several optional components.

• Wayland Session Selector: Allows you to choose a desktop session for your system.
• Gamescope Gaming Mode: Switch to a full-screen gaming experience similar to SteamOS. It uses gamescope-session-steam (Thanks to ChimeraOS team for this).
• GUI Helper: Easy configuration with GUI made with Zenity.
• SDDM Configuration: Automatically configures SDDM for autologin.
• Shortcut Creation: Adds a desktop shortcut for easy switching to Gaming Mode.
• Optional Tools: Offers installation of Flatpak, Decky Loader.
• Session Switcher: Shortcuts to easily switch between desktop and game mode.

• Arch Linux (or an Arch-based distribution)
• SDDM display manager
• A compatible GPU (NVIDIA hardware may face issues)
• A gamepad for best UI experience
• KDE Plasma Desktop (Other desktops are also supported, but KDE Plasma is recommended for the best experience.)

Run this code in your terminal and follow the instructions:

curl -sSL https://raw.githubusercontent.com/unlbslk/arch-deckify/refs/heads/main/install.sh > deckify_install.sh && bash deckify_install.sh; rm -rf deckify_install.sh

And that’s all!

Please note that running this script may modify important system configurations, files, and settings. In some cases, it could lead to system instability, configuration loss, or make the system unbootable. Restoring the system to a working state may require advanced technical knowledge. Before executing directly, check the content of the script.

By using this script, you acknowledge that you are fully responsible for any issues that arise, including but not limited to data loss, system corruption, or any unforeseen consequences. It is highly recommended that you back up your important data and configurations before proceeding. Use this script at your own risk.

1.Prompts you to choose a default session for desktop mode.

2. Installs yay from AUR if neither yay/paru is not installed.

3. Enables the multilib repository, updates the system, and installs Steam if it’s not already installed.

4. Installs gamescope-session-steam-git from the AUR (includes gamescope and other dependencies).

5. Generates an sddm.conf file in /etc/ to enable autologin and session switching.

6. Adds a sudoers rule to allow session switching without a password.

7. Creates a steamos-session-select file, allowing switching back to desktop mode from within Steam.

8. Installs these packages: gamescope, mangohud(for FPS counter), wget, ntfs-3g(for NTFS drive support)

9. Adds a udev rule for backlight control, enabling brightness adjustment within Steam.

10. Creates desktop and application shortcuts for Gaming Mode and a GUI Helper, adds a system update script, and enables Bluetooth services.

The GUI Helper allows you to manually install additional tools like Decky Loader.

The steamos-session-select command allows you to switch between Gamescope (Gaming Mode) and your selected Wayland session. Example usage:

steamos-session-select gamescope  # Switch to Gaming Mode
steamos-session-select desktop     # Switch to Desktop (to your selected session)

You can also switch between Gaming Mode and Desktop Mode easily using the Steam interface or the desktop shortcut created during setup.

To change the session used when switching to Desktop Mode, run the following script:

curl -sSL https://raw.githubusercontent.com/unlbslk/arch-deckify/refs/heads/main/change_default_desktop.sh > deckify_change_default_desktop.sh && bash deckify_change_default_desktop.sh; rm -rf deckify_change_default_desktop.sh

You can update the system in Steam by adding the ~/arch-deckify/system_update.sh file to Steam as a non-Steam game while in desktop mode.

In order for the system update script to work, at least one of the supported terminals (konsole, gnome-terminal, kitty, alacritty) must be installed.

Unfortunately, system updates are not possible through Steam settings.

The Decky Loader is an unofficial community-driven tool that allows you to install and manage plugins for your Steam interface. While not essential for system functionality, it provides additional customization options for SteamOS. (https://decky.xyz/) Please note that it is not an official tool and may cause issues. Any potential risks or problems are the user’s responsibility.

To install Decky Loader:

curl -sSL https://raw.githubusercontent.com/unlbslk/arch-deckify/refs/heads/main/setup_deckyloader.sh > setup_deckyloader.sh && bash setup_deckyloader.sh; rm -rf setup_deckyloader.sh

To remove Decky Loader:

curl -sSL https://raw.githubusercontent.com/unlbslk/arch-deckify/refs/heads/main/remove_deckyloader.sh > remove_deckyloader.sh && bash remove_deckyloader.sh; rm -rf remove_deckyloader.sh

All logos, trademarks, and names related to Steam, SteamOS, Steam Deck, Valve, Deckify and other software such as Plasma and Arch are the property of their respective owners. These logos and names are used for reference and informational purposes only. This project is not affiliated with, endorsed, or sponsored by Valve, Steam, SteamOS, Steam Deck, Plasma, Arch Linux, Flatpak, Decky Loader, Deckify or any of their respective organizations. All rights reserved to the original trademark holders.

A haskell implementation of the Wayland protocol. Any implementation of the Wayland protocol needs to support some C ABI calls if it wants to support EGL, so we just aim to implement the entire C ABI.

At this stage, most work has gone into preliminaries and supporting the C client ABI. That means that this is a piece of really elegant Haskell code that can only really be used by C wayland clients. In other words, this project is currently a drop-in replacement of libwayland-client.so (as of commit 24e5b89, all weston clients seem to run correctly).

However, the aim is to write a really nice Haskell interface so that you can write all your Wayland programs in elegant Haskell. See issue #2 for progress on the usability of this code in Haskell. See issue #3 for progress on the C ABI for compositors (making this a drop-in replacement of libwayland-server.so, thus a replacement of the original C wayland code).

This library builds its own dynamic object (see the foreign-library section in sudbury.cabal). If you have a piece of C code which calls into C libwayland code, and it doesn’t do e.g. hacky pointer arithmetic, then it will work equally well with sudbury. If not, report a bug.

In other words, this project is supposed to be an ABI-compatible drop-in replacement to the C project.

(Currently, it’s client side only, because developer time is finite. But the server side should be doable as well.)

The Haskell bindings to the C wayland library are ugly and are not able to satisfy every need. Ultimately, this seems to be due to the nature of the libwayland API: it hides as many implementation details as it can, and only exposes a minimal API, for a specific use case (namely compositors and windowed clients).

Let’s develop a more friendly and inviting library. Sudbury is an attempt to serve many usages of the wayland protocol: desktop applications, compositors, protocol dumpers, test utilities, …

In addition, we would like to support many different programming paradigms – especially since in Haskell there are many different approaches to streaming IO (lazy IO, conduit, pipes, io-streams, …) and event handling (polling, callbacks, FRP, …).

While libwayland hides implementation details, sudbury exposes implementation details. To that end, as a rule of thumb, the haskell modules in this library expose all the (top-level) variables that they define. In particular, we minimize the amount of code that is considered “internal”. Indeed, the philosophy is that we should not decide what API should be used, but merely offer users a safe API by making that component the most friendly and inviting API.

We intend to place unsafe code in self-contained modules, separated from the Haskell code we intend users to use directly.

The package should be buildable using a development version (i.e. >=1.25) of cabal (development version as of 27 November 2016). As the moment, 27 November 2016, it does not seem to be buildable using stack.

To build with cabal, clone this repository and run

$ cabal sandbox init
$ cabal install

(It is installed locally in a subdirectory of the repository.)

If you installed the project with cabal, you can use it directly. Fire up your favorite wayland compositor, and use cabal exec to run existing executables with the sudbury implementation of the wayland client library:

$ cabal exec weston-flower
$ cabal exec weston-dnd

Portability: The wayland protocol works via unix domain sockets that support passing file descriptors. That means that even if this builds on non-Linux systems, it will likely not work.

• Implement the libwayland ABI to support running existing wayland applications without modification.
  • client-side (mostly done)
  • server-side (not started yet)
• Write a flexible Haskell API.
  • We can use inspiration from the implementation of the ABI to see which components should be exposed and how.
  • The wayland objects all have a corresponding “interface” which is much like a type. Hence, we should use some fancy Haskell features to make the API more strongly typed than libwayland’s.
• Organise the code so that we can do extensive testing and benchmarking.
  • Because of the functional coding style, we will be able to test many more aspects of our code than libwayland.

Most things that require attention should be documented somewhere: either in this readme file, or as an issue on github.

Any feedback on your experience using this library is welcome. Usage here encompasses:

• simply building the library on system X with build system Y
• running a wayland client using the instructions above:
  • are you able to make it use the sudbury implementation?
  • does the client connect?
  • does the client function as it does with libwayland?

For contributing code, you will probably want to get a bit more familiar with wayland. Some notes on understanding wayland are in NOTES.md. To work on:

• work on any of the outstanding issues.
• use sudbury to write tools to e.g. query wayland compositors, or to debug wayland connections. can we rewrite existing debug tools into haskell, using fewer lines of code? can we rewrite the weston client demos?

• hayland: haskell bindings to libwayland (deprecated)
• wayland-wire: alternative haskell implementation of the wayland protocol
• wayland-tracker: haskell utility for tracking what happens between a wayland client and a wayland compositor
• haskell-wlc: haskell bindings to a wayland compositor library

WBC is a dashboard of world bank indicators displayed on a 2×2 grid.
You can reach WBC here: https://data.worldbank.org/indicator

Simplicity was my goal. I wanted different indicators of various countries shown
in an overview to explore relations not normally considered. Something like illegal mining and drug trade in neighbouring countries, for example.

The indicators are fetched using the wbgapi python library.
Graphs are build with plotly.graph_objects.

I’ve considered rebuilding it with html and D3 charts to address long indicator names, legends and spacing.

You can take this project as a base for your own dashboard.

• clone the repo git clone git@github.com:MaCoZu/WB-Commander.git
• navigate in the repo and create a new virtual environment (venv)
  • there are many options for virtual environments I use micromamba and my commaands are
  • micromamaba create -n env_name -f requirements.txt -c conda-forge
• once installed and in the right folder app.py ran be run with python app.py
• the dashboard should run on a specified server adress or better still it opens in a browser tab, if you’ve a Server Extension like Five Server installed.

Feel free to open issues or submit pull requests if you find any bugs or have suggestions for improvements.

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