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/Eskimi
A real-time bidding agent that accepts JSON Requests, does some pattern matching between advertising campaigns and the received bid requests and responds with either a matched campaign bid or an empty response (No Content).
VakinduPhilliam/geoapi
Geolocation Polygons API.
VakinduPhilliam/hardhat
Hardhat is a development environment to compile, deploy, test, and debug your Ethereum software. Get Solidity stack traces & console.log.
VakinduPhilliam/lagom
Reactive Microservices for the JVM
VakinduPhilliam/Scala_Dev_Knight
Principle Scala Data handling Techniques, Exercises, & Coding Challenges.
VakinduPhilliam/serverless-engineering
DynamoDB RESTful API with Pagination and a Serverless Architecture.
VakinduPhilliam/akka-cluster-operator
Run Akka Cluster applications in Kubernetes.
VakinduPhilliam/akkaserverless-java-sdk
Java SDK for Akka Serverless
VakinduPhilliam/cats
Lightweight, modular, and extensible library for functional programming.
VakinduPhilliam/chalice
Python Serverless Microframework for AWS
VakinduPhilliam/cloudflow
Cloudflow enables users to quickly develop, orchestrate, and operate distributed streaming applications on Kubernetes.
VakinduPhilliam/enterprise-setup
Installation resources for CircleCI Enterprise
VakinduPhilliam/flutter
Flutter makes it easy and fast to build beautiful apps for mobile and beyond.
VakinduPhilliam/flutter_carousel_slider
A flutter carousel widget, support infinite scroll, and custom child widget.
VakinduPhilliam/js-ceramic
Typescript implementation of the Ceramic protocol
VakinduPhilliam/mosquitto
Eclipse Mosquitto - An open source MQTT broker
VakinduPhilliam/mqtt.github.io
website
VakinduPhilliam/nest
A progressive Node.js framework for building efficient, scalable, and enterprise-grade server-side applications on top of TypeScript & JavaScript (ES6, ES7, ES8) 🚀
VakinduPhilliam/paho.mqtt.c
An Eclipse Paho C client library for MQTT for Windows, Linux and MacOS.
VakinduPhilliam/paho.mqtt.python
paho.mqtt.python
VakinduPhilliam/plugins
Plugins for Flutter maintained by the Flutter team
VakinduPhilliam/prisma
Next-generation ORM for Node.js & TypeScript | PostgreSQL, MySQL, MariaDB, SQL Server, SQLite & MongoDB (Preview)
VakinduPhilliam/react-redux
Official React bindings for Redux
VakinduPhilliam/redux
Predictable state container for JavaScript apps
VakinduPhilliam/redux-thunk
Thunk middleware for Redux
VakinduPhilliam/serverless
⚡ Serverless Framework – Build web, mobile and IoT applications with serverless architectures using AWS Lambda, Azure Functions, Google CloudFunctions & more! –
VakinduPhilliam/shapeless
Generic programming for Scala
VakinduPhilliam/spark-deep-learning
Deep Learning Pipelines for Apache Spark
VakinduPhilliam/spray-json
A lightweight, clean and simple JSON implementation in Scala
VakinduPhilliam/Tagprotocol
TAG Protocol is a DAO (Digital Autonomous Organization) operating Hashtag registry, Staking & Trading service on Binance Smart Chain. Users can register and perpetually own unique social media Hashtags just like they register & own domain names and use them to mine Tagcoin (Native protocol coin) by participating in daily Hashtag Staking Pool. Users can exchange Tagcoin for other crypto-currencies such as BNB, USDT at market rate immediately on Tag Exchange. Users can also trade Hashtags with other users at Hashtag Auction Marketplace in exchange for other crypto-currencies.