VakinduPhilliam
Node.JS Backend/Frontend Developer, UI/UX, Flutter/Dart, RESTful APIs, Android/iOS Mobile Developer, Python/Django, AI, JavaScript, PostgreSQL, Scala.
@appwrite Kampala, Uganda
Pinned Repositories
appwrite
Your backend, minus the hassle.
Cryptographic_Signatures
Explore Django's Low-level and high-level API for signing values with Python.
Multiprocess_Coroutines
The following scripts are written to demonstrate the use of Python Coroutines and Tasks. Coroutines declared with async/await syntax is the preferred way of writing asyncio applications. To actually run a coroutine, asyncio provides three main mechanisms: > The asyncio.run() function to run the top-level entry point “main()” function. > Awaiting on a coroutine: An object is an awaitable object if it can be used in an await expression. Many asyncio APIs are designed to accept awaitables. > The asyncio.create_task() function to run coroutines concurrently as asyncio Tasks. There are three main types of awaitable objects: coroutines, Tasks, and Futures. Coroutines: Python coroutines are awaitables and therefore can be awaited from other coroutines. Tasks: Tasks are used to schedule coroutines concurrently. When a coroutine is wrapped into a Task with functions like asyncio.create_task() the coroutine is automatically scheduled to run soon: Futures: A Future is a special low-level awaitable object that represents an eventual result of an asynchronous operation. When a Future object is awaited it means that the coroutine will wait until the Future is resolved in some other place. Future objects in asyncio are needed to allow callback-based code to be used with async/await. Normally there is no need to create Future objects at the application level code. Future objects, sometimes exposed by libraries and some asyncio APIs, can be awaited: Compiled and presented by Vakindu Philliam.
Multiprocess_Parallelism
Spawning multiple concurrent processes in Python using subprocesses instead of threading.
Node.js_Blockchain
Building a Blockchain peer-to-peer network using Node.js and Socket.io.
Node.js_REST
Explore next generation concepts in Node.js RESTful API application development.
NodeJS_Clean_Architecture
NodeJS Clean Architecture. Clean Architecture is an opinionated boilerplate for Node web APIs focused on separation of concerns and scalability with Uncle Bob Clean Architecture implementation. Features: > Union - Layered folder structure: code organization focused on codebase scalability. > Instant feedback and reload: use Nodemon to automatically reload the server after a file change when on development mode, makes the development faster and easier. > Scalable and easy to use web server. > Use Express for requests routing and middlewares. There are some essential middlewares for web APIs already setup, like body-parser, compression, and method-override. > Database integration: Mongoose, a MongoDB Database Connection, is already integrated; you just have to set the authentication configurations. > Prepared for testing: The test suite uses Mocha, Chai and is prepared to run unit, integration and functional tests right from the beginning. A FactoryGirl adapter for Mongo is setup to make your tests DRY as well, and the tests generate code coverage measurement with. You should read about the Chai plugins that are setup by default too. > Dependency injection: With Awilix, a practical dependency injection library, the code will not be coupled and it'll still be easy to resolve automatically the dependencies on the runtime and mock them during the tests. It's even possible inject dependencies on your controllers with the Awilix Express adapter. >Logging: The Log4js logger is highly pluggable, being able to append the messages to a file during the development and send them to a logging service when on production. Even the requests (through Morgan) and queries will be logged. > Linter: It's also setup with ESLint to make it easy to ensure a code styling and find code smells. How to use: Notice that the boilerplate comes with a small application for user management already; you can delete it with a npm script after you understand how the boilerplate works but please do the quick start first! 1. Clone the repository. 2. Setup the database on `config/database.js` (there's an example file there to be used with MongoDB). 3. Install the dependencies with `yarn`. 4. Create the development and test databases you have setup on `config/database.js` 5. Run the application in development mode with `npm run dev` 6. Access `http://localhost:3000/api/users` and you're ready to go! Compiled and presented by Vakindu Philliam.
Pattern_Matching
The following scripts are written to demonstrate how to compare sequences in Python using the ‘difflib’ module. ‘difflib’ contains a series of helpers for computing deltas. This module provides classes and functions for comparing sequences and pattern matching. It can be used for example, for comparing files, and can produce difference information in various formats, including HTML and context and unified diffs. class difflib.SequenceMatcher This is a flexible class for comparing pairs of sequences of any type, so long as the sequence elements are hashable. The basic algorithm predates, and is a little fancier than, an algorithm published in the late 1980’s by Ratcliff and Obershelp under the hyperbolic name “gestalt pattern matching.” The idea is to find the longest contiguous matching subsequence that contains no “junk” elements; these “junk” elements are ones that are uninteresting in some sense, such as blank lines or whitespace. (Handling junk is an extension to the Ratcliff and Obershelp algorithm.) The same idea is then applied recursively to the pieces of the sequences to the left and to the right of the matching subsequence. This does not yield minimal edit sequences, but does tend to yield matches that “look right” to people. Timing: The basic Ratcliff-Obershelp algorithm is cubic time in the worst case and quadratic time in the expected case. SequenceMatcher is quadratic time for the worst case and has expected-case behavior dependent in a complicated way on how many elements the sequences have in common; best case time is linear. Automatic junk heuristic: SequenceMatcher supports a heuristic that automatically treats certain sequence items as junk. The heuristic counts how many times each individual item appears in the sequence. If an item’s duplicates (after the first one) account for more than 1% of the sequence and the sequence is at least 200 items long, this item is marked as “popular” and is treated as junk for the purpose of sequence matching. This heuristic can be turned off by setting the autojunk argument to False when creating the SequenceMatcher. class difflib.Differ This is a class for comparing sequences of lines of text, and producing human-readable differences or deltas. Differ uses SequenceMatcher both to compare sequences of lines, and to compare sequences of characters within similar (near-matching) lines. Compiled and presented by Vakindu Philliam.
Scala_Dev_Knight
Principle Scala Data handling Techniques, Exercises, & Coding Challenges.
Socket_Programming
Sockets for client-server communication. The combination of sockets with INET makes talking to arbitrary machines on a global network unbelievably easy.
VakinduPhilliam's Repositories
VakinduPhilliam/akka
Build highly concurrent, distributed, and resilient message-driven applications on the JVM
VakinduPhilliam/akka-http
The Streaming-first HTTP server/module of Akka
VakinduPhilliam/core
The ARK Core Blockchain Framework. Check https://learn.ark.dev for more information.
VakinduPhilliam/cosmos-sdk
:chains: A Framework for Building High Value Public Blockchains :sparkles:
VakinduPhilliam/desktop-wallet
:computer: Multi Platform ARK Desktop Wallet
VakinduPhilliam/fabric-sdk-node
Hyperledger Fabric SDK for Node https://wiki.hyperledger.org/display/fabric
VakinduPhilliam/gecko
Official Go implementation of an AVA node.
VakinduPhilliam/git-scm.com
The git-scm.com website. Note that this repository is only for the website; issues with git itself should go to https://git-scm.com/community.
VakinduPhilliam/go
The Go programming language
VakinduPhilliam/gochain
The official GoChain client.
VakinduPhilliam/hadoop
Apache Hadoop
VakinduPhilliam/hive
Apache Hive
VakinduPhilliam/kafka
Mirror of Apache Kafka
VakinduPhilliam/minio
MinIO is a high performance object storage server compatible with Amazon S3 APIs
VakinduPhilliam/minio-go
MinIO Client SDK for Go
VakinduPhilliam/minio-java
MinIO Client SDK for Java
VakinduPhilliam/minio-js
MinIO Client SDK for Javascript
VakinduPhilliam/node-XMLHttpRequest
XMLHttpRequest for node.js
VakinduPhilliam/pig
Mirror of Apache Pig
VakinduPhilliam/playframework
Play Framework
VakinduPhilliam/polkadot
Polkadot Node Implementation
VakinduPhilliam/ravepay-nodejs
Rave by Flutterwave Nodejs SDK.
VakinduPhilliam/sbt
sbt, the interactive build tool
VakinduPhilliam/spark
Apache Spark
VakinduPhilliam/storm
Mirror of Apache Storm
VakinduPhilliam/substrate
Substrate: The platform for blockchain innovators
VakinduPhilliam/treebeard
🌲 Reproduce data science projects in the cloud
VakinduPhilliam/wp-rave-payment-forms
Take donations and payments for services on your WordPress site using Rave.
VakinduPhilliam/zinc
Scala incremental compiler library, originally part of sbt
VakinduPhilliam/zookeeper
Mirror of Apache Hadoop ZooKeeper