DEV Community: Ahmed Noor E Alam

Lino - A command line text editor with notepad like key bindings

Ahmed Noor E Alam — Tue, 02 Feb 2021 07:19:35 +0000

Hey Everyone, I hope you are all doing great.

I am quite a noob in Rust programming language. So, in order to play with it and make something serious, I have recently made a command-line text editor with Notepad like key bindings.

Features:

Notepad like keybindings.
Multi-line indentation.
Auto-indented new lines.
Line numbers.
Syntax highlighting.
Copy, Paste.
Undo, Redo.
Find, Replace.

Your love and feedback will be greatly appreciated. (Link Below)

Link: https://github.com/ahmednooor/lino

Thank You && Take Care 😊

react-scroll-restorer

Ahmed Noor E Alam — Sun, 06 Dec 2020 15:36:35 +0000

Hey every one, I hope you are all doing great.

I have just published a React package react-scroll-restorer that helps restoring old scroll positions after component re-mounts.

Your feedback & love will be greatly appreciated. Link to the GitHub repo below.

https://github.com/ahmednooor/react-scroll-restorer

Thank you 😊

Hacking my way into creating a free URL shortening service by knitting several free pieces of the Internet

Ahmed Noor E Alam — Mon, 02 Nov 2020 23:56:09 +0000

The most important part of a URL shortening service is a short domain. It had to be free, so thanks to freenom.com for that :)
Now a free backend server was required. But there weren't much services that were actually free and provided a good basic service as well. But thanks to pythonanywhere.com for that :)
- But wait, they don't let you have a separate IP. hmmm ...
- Ok, I will just add the A record in my DNS to my pythonanywhere app's sub-domain. Problem solved!
- Not so fast. If only I had known that you can't put domain names in A records. hmmm :/
- Ok, so I found something interesting from pythonanywhere forums. You can redirect your naked domain i.e. example[dot]com to www[dot]example[dot]com by using an IP from a free service called wwwizer.com and then you can add a CNAME record for www and redirect that to your pythonanywhere app's sub-domain. Ok, lets do that!
- :/ hmmm... it seems that pythonanywhere guys are clever. They don't let you go to your app's sub-domain from a www redirect unless you are a paying client.
Ok, it seems that it isn't gonna work, so lets just leave it ...
So, I had an idea the next day. What if I used another free service that lets me host a static page, and I could redirect from my DNS to that static page which would then redirect to the actual site hosted at pythonanywhere? Hmmm ... so what platform lets you have static pages? Aha! it's github.com.
So after experimenting, I came to know that I can't redirect my CNAME record to anything that has a path following the actual domain e.g. username[dot]github[dot]io is fine but username[dot]github[dot]io/something is not. Which means I would need to make a github organization to have a separate username[dot]github[dot]io domain.
Ok, done that, but it seems that github pages doesn't support dynamic routing e.g. if you enter username[dot]github[dot]io/something, it will look for a repo with the name something instead of serving the page at the root domain and let you parse the /something yourself. Which makes sense since it is a static file hosting platform.
Thanks to the awesome people who created this spa-github-pages hack/solution. It lets you handle all dynamic routes on a single static file. Check out their README for more details.
Finally! it's done and it works.

You can try it out on rout.ml

Source code is available at github.com/routml

It might not work always due to the limitations of free-ness. So if you are looking at this from the future, thank you for your time :) I hope this has been helpful to you in some way.

Below is a diagram that shows how the request from the naked public domain goes all the way to the actual app hosting sub-domain.

I hope this has been interesting for you.
Take Care && Good Bye. 😊

Implementing Polymorphism in Rust

Ahmed Noor E Alam — Thu, 02 Jul 2020 03:02:03 +0000

In this post we will be implementing Polymorphism in Rust.

But what is Polymorphism?
In simple terms, it is the ability to pass an argument that can be of different types, to a function with only one implementation, instead of separate ones for each different type.

Code: Online Demo Link

// Polymorphism in Rust
// Online Demo: https://repl.it/repls/PerfectSandybrownCarat

const PI: f64 = 3.1416;

struct Circle {
  radius: f64
}

struct Rectangle {
  height: f64,
  width: f64
}

// Since both Circle and Rectangle are shapes,
// we can label common behavior in a `trait` type.
// A `trait` is basically a type that groups
// certain behaviors that are similar in meaning
// but can be different in implementation. e.g. a
// dog and a human, both can walk, but they walk
// differently. You can also think of traits as 
// kind of similar to interfaces in other languages.
trait Shape {
  fn area(&self) -> f64;
}

// Although both shapes have an area
// but their ways of calculating it
// are different. e.g. (dog human walking analogy)
impl Shape for Circle {
  fn area(&self) -> f64 {
    PI * self.radius * self.radius
  }
}
impl Shape for Rectangle {
  fn area(&self) -> f64 {
    self.height * self.width
  }
}

// Here, we are saying, hey accept
// any type that implements a `trait`
// called Shape. e.g. any object that
// can walk (from dog human analogy).
fn print_area(shape: &dyn Shape) {
  println!("{}", shape.area());
}

// Or we can also make a generic function.
// This is similar to `print_area` but may
// have the benifits of static type checking,
// since it's a generic, so two versions of the
// same function get generated with relevant
// absolute/concrete types. (not sure though)
fn print_area_generic<T: Shape> (shape: &T) {
  println!("{}", shape.area());
}

fn main() {
  let circle = Circle{radius: 2.0};
  let rectangle = Rectangle{height: 3.0, width: 5.0};

  print_area(&circle); // 12.5664
  print_area(&rectangle); // 15

  print_area_generic(&circle); // 12.5664
  print_area_generic(&rectangle); // 15
}

I hope this has been interesting for you.
Take Care && Good Bye. 😊

Attempting OOP in the Functional Paradigm

Ahmed Noor E Alam — Fri, 26 Jun 2020 00:18:55 +0000

Imagine if OOP was developed using Functional Programming concepts. In this post I will be trying to explore that in JavaScript.

JS Code: (Online Demo Link)

/* OOP in a Functional way, with HOFs, Currying and Closures.
 * Online Demo: https://repl.it/repls/BelovedLikelyDebugger */

const Rectangle = (h, w) => {
    let _h = h;
    let _w = w;

    const methods = [
        ["getH", _ => _h],
        ["getW", _ => _w],
        ["getArea", _ => _h * _w],
        ["setH", h => { _h = h; return getMethod; }],
        ["setW", w => { _w = w; return getMethod; }],
    ];

    const getMethod = methodName => {
        const method = methods.filter(
            method => method[0] === methodName);

        // If method was found, then return it, else raise error
        if (method.length > 0 
            && method[0].length > 0 
            && typeof method[0][1] === 'function')
                return method[0][1];

        throw new Error(`"${methodName}" is not a method name.`);
    };

    return getMethod;
    // ^ Since the returned `getMethod` function uses `methods` array
    // which contains functions that use the `_h` and `_w` variables,
    // those variables don't get cleaned up when the function returns.
    // Hence we have a saved state mimicking object fields.
    // `getMethod` and functions in `methods` array are called
    // Closures, because they kinda enclose local variables and
    // keep them from being cleaned up.
};

const myRectangleObject = Rectangle(2, 3);
// `myRectangleObject` is actually a function returned
// by `Rectangle` which is a Higher Order Function (HOF).
// A HOF is a function that either takes functions
// as arguments or returns a function.
// In our case, the `Rectangle` HOF returns another
// HOF `getMethod` since it also returns a function
// upon calling. See below for demonstration.

console.log(myRectangleObject("getArea")()); // 6

myRectangleObject("setH")(4); // sets _h to 4
// ^ The first call `("setH")` returns another function
// that has the ability to change the local variable `_h`.
// The second call `(4)` then changes the `_h` variable.
// This sequential passing of arguments is Currying.

myRectangleObject("setW")(5); // sets _w to 5
console.log(myRectangleObject("getArea")()); // 20

Confused much? 😀
Lets go through it once again, in steps.

Rectangle takes two arguments h and w and stores their values in local variables _h and _w.
Rectangle has a local 2D array called methods. It contains a string in first column and an anonymous function in second column in each row. The string can be used as sort of an identifier for the function.
Rectangle returns a function called getMethod.
getMethod takes a string as an argument and uses that to filter out a matching pair of string and anonymous function in methods 2D array. If it finds such pair, then it returns the anonymous function from that pair. Otherwise, it raises an error.
Based on what anonymous function got returned from getMethod, we can perform different operations on local variables _h and _w such as setting different values and getting their product i.e. area etc.. We can do this magic because the anonymous function that got returned and the local variables are in the same lexical scope.

I hope this has broadened (confused) your horizons a lot. 😀

And for the bonus, below is a snippet of the same concept implemented in Scheme Programming Language which is a dialect of Lisp.

Scheme Code: (Online Demo Link)

; OOP in a Functional way
; Online Demo: https://repl.it/repls/CalmSmoothClasslibrary
(define (Rectangle h w)
        (define _h h)
        (define _w w)
        (define methods (list
                        (cons "getH" (lambda () _h))
                        (cons "getW" (lambda () _w))
                        (cons "getArea" (lambda () (* _h _w)))
                        (cons "setH" (lambda (h) (set! _h h) getMethod))
                        (cons "setW" (lambda (w) (set! _w w) getMethod))))
        (define (getMethod methodName)
                (cdr (car (filter 
                          (lambda (n) (equal? (car n) methodName))
                          methods))))
        getMethod)

(define myRectangle (Rectangle 2 3))
(print ((myRectangle "getArea"))) ; 6
((myRectangle "setH") 4) ; sets _h to 4
((myRectangle "setW") 5) ; sets _w to 5
(print ((myRectangle "getArea"))) ; 20

And that's it for now. Thank you.
Take Care && Good Bye. 😊