OSS Review Toolkit’s Post

Also see https://lnkd.in/e3HBhCz6 in this context.

Have you ever thought about publishing your own npm library? I recently did, by publishing pushdown-automaton. A package that allows the user to easily create and run pushdown automata. Check out my blog article on how to also publish something to npm: https://lnkd.in/dqb8Eq3m

Local code is usually better than relying on external dependencies ♻ Recently, I came across a simple JavaScript library that serves a specific purpose and nothing more. It exports only one function that checks if a value is odd or even, whether it's a string or a number. Additionally, it ensures that the number is below MAXIMUM_SAFE_INTEGER, the largest integer supported by JS (https://lnkd.in/e9ZCjrb2). While the irony of this situation is not lost on me, I want to emphasize two important points. As a JavaScript developer, regardless of whether you work on the back-end, front-end, cross-platform, or full-stack, it's highly likely that you interact with external dependencies. This is one of the advantages of working with JS, its extensive community offers libraries for solving almost any issue you may encounter. These open source projects not only provide solutions but also serve as a valuable source of learning. However, when considering adding a new dependency to your project, it's crucial to assess its popularity. If a library is not well-maintained, lacks testing, or has low adoption, it can introduce more problems than it solves. Dealing with your own bugs is one thing, but reaching out to the developers of an unmaintained library, waiting for a response, and having to find temporary solutions in the meantime can quickly become chaotic. While there are undoubtedly excellent open source solutions like RTK, MUI, Zustand, etc., for smaller logic that you can implement yourself, I recommend opting for your own solution even if you come across a library that already handles it. Lastly, I would like to wrap things up with the second point that I wanted to raise: let's all maintain a high level of quality, even in our smallest projects, as demonstrated by that repository contributors (they even included tests). #programming #interesting #dependency #javascript

Creating your own state management library for React involves understanding the principles of state management, handling state updates, and providing a way for React components to interact with the state. Below is a simplified example of how you might create a basic state management library for React. Please note that this is a minimalistic illustration, and real-world state management libraries are more complex. Read More: https://lnkd.in/gs-hAbss

Excited to announce a new project: Seaweed 🌊 Seaweed is a lightweight, single-threaded HTTP library written in C. It provides a simple and intuitive interface for creating an HTTP server, following the simplicity of frameworks like Express.js and FastAPI. But what sets it apart is that it’s written entirely from scratch in C. Github link: https://lnkd.in/g9Q_PHfv The primary motivation behind Seaweed was to dive into the nitty-gritty of the HTTP protocol and build something from the ground up to gain hands-on experience with how low-level systems are structured. The journey was challenging but incredibly rewarding. I spent countless hours poring over the HTTP protocol RFCs, learning the ins and outs of TCP socket programming, and ensuring most parts of the server worked as expected. Designing a C library with reusable components taught me invaluable lessons about structuring low-level code, and increased my appreciation for the constructs offered by application languages. While low-level network programming is no easy task, it offered a unique opportunity to work directly with the operating system and truly understand what happens under the hood when a request is made. I learned so much about manual memory management, system-level programming, and how networking protocols actually function. These experiences not only gave me a deeper appreciation for how much abstraction modern frameworks provide, but also made me realize the power of C as a language for systems programming. I know that many developers shy away from C because of its complexity and low-level nature, but I would highly encourage everyone to brush up on their low-level programming skills every now and then. It helps you gain a more profound understanding of how your applications interact with the OS, the fine details of resource management, and how to write more efficient, optimised code. C might be intimidating, but the level of control and precision it offers is unparalleled and teaches you skills that carry over to higher-level languages and design patterns. I would've never thought during my first year C course that I'd be using function pointers directly, but I truly appreciate the flexibility they offer now. What’s next for Seaweed? I’m planning to add some exciting features like multi-threading for handling incoming requests concurrently, UNIX socket support, and the ability to add custom headers to outgoing HTTP responses. These improvements will not only make Seaweed more powerful but will continue to push my understanding of the underlying concepts even further. I’ll also be writing a blog post soon to dive deeper into the project, the challenges I faced, and the lessons I learned from building an HTTP server from scratch. Stay tuned for a more detailed explanation of everything involved in building an Http server. #CProgramming #HTTP #Networking #LowLevelProgramming #TCP #SystemsProgramming #SoftwareDevelopment #Engineering

🚀 #day13 of #30daysofcodechallenge 📌 Q. Implement Stack using Linked List :) Let's give it a try! You have a linked list and you have to implement the functionalities push and pop of stack using this given linked list. Your task is to use the class as shown in the comments in the code editor and complete the functions push() and pop() to implement a stack. Example 1: Input: push(2) push(3) pop() push(4) pop() Output: 3 4 Explanation: push(2) the stack will be {2} push(3) the stack will be {2 3} pop() poped element will be 3, the stack will be {2} push(4) the stack will be {2 4} pop() poped element will be 4 #dsa #dsachallenge #stack #problemsolvingskills ✍

Tired of writing boilerplate code? This project tackles that problem by building a robust Library Management System API with a focus on re-usability and clean architecture. Built with: TypeScript for strong typing and improved maintainability. Nest.js framework for efficient server-side development on Node.js. Features: - Comprehensive Book Management: Add, update, delete, and list books with details like title, author, ISBN, quantity, and location. Search for books by title, author, or ISBN. - Borrower Management: Register, update, delete, and list borrowers. - Streamlined Borrowing Process: Borrowers can check out, return, and view their borrowed books. System tracks due dates and flags overdue books. Advanced Functionality: -- Rate Limiting: API endpoints are protected against abuse. -- JWT Authentication: Secure access to system functionalities. -- Pagination: Efficiently handle large datasets. -- Database Indexing: Optimizes database queries for performance. -- Role-Based Access Control (RBAC): Defines user permissions. -- Dockerization: Simplifies deployment with Docker Compose. Introducing CoreModule - The Abstraction Powerhouse! This project introduces a groundbreaking concept - CoreModule. It houses a collection of reusable classes designed to minimize boilerplate code and streamline API development: -- CoreController: Base controller for consistent API structure. -- CoreService: Shared service logic for common operations. -- FilterCoreDto: Defines filtering criteria across entities. -- CoreModel: Base model for efficient data representation. -- AuditModel: Tracks creation and modification timestamps. CoreModule Benefits: -- Reduced Boilerplate: Inherit from CoreModule classes to gain access to pre-built functionalities. -- Ready-to-Use Features: Pagination, sorting, filtering, serialization, and enhanced response formatting - all at your fingertips. -- Generic CRUD Operations: FindAll, FindOne, Create, Update, PartialUpdate, and Delete (hard or soft) for effortless data manipulation. Additional Enhancements: -- Caching: Leverages Redis for database and response-level caching. -- Logging: LoggerInterceptor automatically logs essential information. Ready to explore the code? Check out the project on GitHub: https://lnkd.in/dhn3G2WV Let's ditch the boilerplate and focus on what truly matters - building innovative solutions! #softwareengineering #softwaredevelopment #backenddevelopment #nodejs #nestjs #typescript #docker #postgresql #redis #abstraction

Day 12/100 of #100DaysOfCode DSA: Worked on strings and some medium-level questions. Completed some challenging problems and kept up my streak on LeetCode. Day 26 of Web Development: This is JavaScript project number 3. Continued working on my project 3 using HTML, CSS, and JavaScript. I do Java practice only. This is my GitHub link: https://lnkd.in/g7KE7hkm. #LearnInPublic #BuildInPublic #100DaysOfCodeChallenge #WebDevelopment

Below is a simple console-based task management system implemented in Java using ArrayList for storage: #sszonetechnologies https://lnkd.in/dg_ZP-k9

#CoreJava #LearnToExpert >Learner from TELUSKO >>> Case Studies on Method Overloading Case Study1. Automatic type promotion: > byte --> short --> int --> long --> float --> Double >char --> int >there is no type promotion for Double, it gives compile-time error when exact match are not there. >argument automatic type promotion will occur when exact match methods are not there. Case Study2. Objects as arguments(Parent and Child class): >Object (parent class) --> String (child class) >child class argument object method has the highest priority compare to parent class argument object when the both are matched in overloading(Object + String ==> String). Parent will get chance when there is no child(Object == Object). Case Study3. Reference to method(m1()) is Ambiguity(if both are child class arguments): >String (child class)--> StringBuffer (child class). >if we pass null as argument then both String and StringBuffer are manageable than compiler confuses which method want to invoke then it leads to compile-time error as reference to m1() is ambiguity occurs beacuse both string and stringbuffer are the child classes of object class. Case Study4. Var-args method argument vs General Method: >we invokes var-args method as no argument as well as multiple arguments and var-args method has the least priority compared to general method, because var-args introduced in 1.5 version. >whenever the battle between old concept and new concept is occur then old concept is has the highest priority compared to new concept in overloading. > we have methods m1(int i) and m1(int... i) then we pass int val as argument then both are matched then general method m1(int i) will get invokes because general method. Case Study5. Reference to method m1() is Ambiguity(types): >m1(int i,float f) and m1(float f, int i) then if we pass m1(10,10) then both are manageable the compiler confuses which method to invokes then it leads to reference to m1() is ambiguity is occurred in overloading. >m1(int i,float f) and m1(float f,int i)if we pass as m1(30.5,30.5) then it leads to compile-time error as no such suitable method to invokes. Case Study6. Compile-time Resolution: >method overloading is also known as compile-time polymorphism/static polymorphism/early binding. In method overloading method resolution is done at compile-time not run time. So we can not invoke the child method through parent reference. >Parent p = new Child(); --> Animal a1 = new monkey(); >m1() of child class we can not access with parent reference. >a1.m1(); it invokes the method of m1() of Animal not Monkey. https://lnkd.in/giQgsR-g