Have you heard about Competitive programming ?

---

Competitive Programming

If you are looking for job in Google,Amazon or facebook as programmer or developer/designer, definitely you will be familiar with the word "Competitive programming ".

I thought of sharing some of my thoughts on "competitive programming ".
As per wikipedia - Competitive programming is a mind sport usually held over the Internet or a local network. https://en.wikipedia.org/wiki/Competitive_programming

As per definition it’s a “sports”

I heard about hackerrank 3 or 4 years back. I got surprised seeing the success of hackerrank. Definitely its very useful website those who are trying to understand different algorithms/concepts/problems in computer science. After that there was a rain of similar websites … Codechef, CodeByte etc …etc … I don’t know which one of these came first.

But I would suggest nothing harm in login those websites and try to solve some of the problems . Don’t get disappointed /discouraged if you are not able to solve the questions. you don’t need to be a competitive programmer to be a programmer.

I am not huge fan of competitive programming. But it improves your programming skill in multiple perspective and definitely you might need to have this skill for getting into Product based Software companies like Google, Amazon and facebook etc . When I started trying to solve some of the problems in code force , I thought I would require PHD in mathematics to understand the problems . Most of them will be really tough mathematical problems. But if you start from easy , medium and then to difficult once, I hope you won’t need to run away from it :-)

Let me start with advantages of Competitive programming

• You are going to get good understanding on the Algorithms and data structures .

• You will get to know different areas in computer science - number theory,set theory,graph theory,string analysis etc. If you ask me , Are these mathematics subjects? I would need to say “YES”. But the fact is you need to have good understanding on these areas in order to develop something unique. ( This is debatable subject) , you can develop innovative or useful applications without much deep understanding on these areas.

• definitely it’s a plus point for you to get into Software companies.

• This gives you the ability to approach problems in different ways and helps to get the optimized one.

• Definitely you will come to time complexity O(n) and space complexity in computer programming :-)

• Some of the competitive programming sites gives you only limited time to solve the problem. When you start solving the problems in time bound question ,this helps a lot in interviews. You will be able to face the software companies interviews more efficiently.

I think I wrote some advantages , so let me mention some of the websites you can try this .

• Codechef
• Codecup
• Codeforces
• CodeGround
• CodeJam
• DoSelect for developers
• GeeksForGeeks
• GeekyPrep.com
• Hackerearth
• Hackerrank
• InterviewBit
• Kattis
• LeetCode
• Programming Hub
• Spoj
• TechGig
• Techie Delight
• Topcoder
• UVa Online
• FreeCodecamp

In my opinion you don’t need to be competitive programmer to become a programmer/developer.

Competitive programming Drawbacks:

• First of all , its not a technology or programming style or skill that every programmer is needed. Everybody know we need good algorithms to perform the program well. Reading,writing,debugging programs will makes you skillful programmer. Sometimes competitiveness makes to take decision immediately or jump into conclusion quickly.

• For getting into competitive programming there are some prerequisites - good mathematical knowledge, Computer languages that the websites are using, good knowledge in computer science concepts.

• If you are trying to learn a programming language from basics (eg: C programming ), I don’t think those sites are the starting point. Those who are good in C, C++,python etc languages , these websites will be a good place to play around.

• Competitive programming will not take you to most of the computer applications areas .
  eg: Those who are interested in embedded systems , will not get any knowledge on peripheral or architecture of the micro controller/processor from this. or those who are all interested website designing and development not going to get much from competitive programming apart from understanding on the algorithms or logical thinking.

• Nowadays Application building is like “building blocks” game. More you know about libraries and modules on the area, you will be succeeded in building some good applications.

• Software life cycle is totally different - As you know it start with requirement gathering,designing,coding,unit testing, functional testing and User acceptance testing and deployment etc. I don’t see competitive programming give much importance to designing and collaboration and testing.

• If you look at object oriented programming or functional programming , they are a programming style that every programmer should be aware of .

• You can build innovative applications without competitive programming skills.

Conclusion

Please don’t consider Competitive programming as waste of time. It will definitely improve knowledge on algorithms and computer theories. Keep improving your programming skill on competitive perspective as well. Also be ware of that there are lot of other areas in programming where we can focus on application building or we can playground. As I said earlier You don’t need to be competitive programmer to be developer/programmer.

Please share your thoughts and comments. Thanks!

Rust Iterators

Iterators in Rust programming

Nowadays Iterators are every programmer’s tool in hand.When I program array of objects/strings in C programming , I always wish that I could have some tool/function/operator where we can iterate through these objects or strings(words). “for” loop or “while” loop are going through array index in C programming .

If you are storing words in Array it become 2 dimensional array. So iterating through “words” become even more difficult in C programming .But it will be convenient if you can iterate through the types values/objects in the array. eg: Array(“I”,“like”,“rust”,“programming”) …if you can just iterate through the words rather than reading through the letters, it will be easy to make the words manipulations.

It is Functional programming style where we can just tell the program to iterate through the specified type .
Another use case would be eg: In the given Array (2,4,6,8) of elements if we want to find cube for all the elements in the array and then filter if cube is even number.

For conventional Loop structure we will be iterating through each element and find cube then check and filter if it is even. How great it would be if we can have something like below give us the same output number/maths calculations

example: array.iter().filter(x/2==0).collect()

eg2: words or sentence manipulation

array.iter().filter( words_contains_vowels)

It improves the readability of the program a lot. This functional programming style improves the readability ,but at the same time we can’t compromise the performance . Since they are as fast as our native loops , they are “Zero cost abstraction” in Rust ## iter from standard library The standard library std::iter provides Trait is Iterator. You want to build iterator any Struct ,

you can implement Iterator on your collection with below trait

trait Iterator { type Item fn next(&mut self) ->Option(Self::Item); }

In the below example, suppose if I have an input stream coming from outside and I want to iterator over word by word

//the structure which store the words and index of the words
//note :Since we are using String slice reference , the life time needs to provided explicitly 

struct Mystream<'a>{
    words: Vec<&'a str>,
    index:usize
}

//implementing the structure with methods "new" and "next_word"
//"new" method create a structure object with words generated from  stream
//next_word method calls next method in the Iterator trait

impl <'a>Mystream<'a>{

//"new" method get the string and split them into words vector
//index will be zero for object, but we will increment it in each iteration and use it as indexing the vector
    fn new(stream:&'a str) -> Mystream{
        Mystream{
             words : stream.split(' ').collect(),
             index:0,
        }
    }

//next_word method calls the "next" method from the iterator trait    
    
    fn next_word(&mut self) ->Option<&'a str>{
            self.next()
    }

}

//standard implementation for Iterator for "Mystream" struct

impl <'a>Iterator for Mystream<'a>{
    type Item = &'a str;
    
    fn next(&mut self) -> Option<&'a str>{
            self.index +=1;
            match Some(self.words[self.index]){
                Some(word) => Some(word),
                None => None,
            }
    }
}



fn main(){
    
    let mut mystream = Mystream::new("I like to implement Rust Iterator for my stream");
    let mut len = mystream.words.len();
    println!("{:?},{}",mystream.words[0],len);
    len = len -1;
    while len > 0 {
    
         println!("{:?},{}",mystream.next_word().unwrap(),len);
         len = len -1;
    }
    
}

Not sure above example is tough one, but let me try to explain it… Let assume we have a stream of words coming from input port, our task is to store it in a struct as words .(ie: split the sentence into words). I tried to explain most of the things in the comment section. But still we will go through it … The implementation of Iterator for “Mystream” struct is important part in the code. For understanding Iterator implementation you should know what is trait and struct creation and implementation of struct in rust

If look at the Iterator trait documentation, they ask us to create an associated type Item (Associated types are a way of associating a type placeholder with a trait such that the trait method definitions can use these placeholder types in their signatures.) and required method “next”

The next method passing parameter and return parameters are mentioned in the example.

As a general rule , for any Trait Rust documentation you will get the required methods or associated types needs to implemented for using it for your struct. Also we need to implement that Trait for our struct.
This case,

impl <'a>Iterator for Mystream<'a>

Since we are using vector of string slice(a reference type), we need to provide life time for it and struct.

Here we have given the associated type Item as &'a str (string slice) which means we are planning to iterate through string slice when the next method calls.

Return type for next method is Option <Self:Item> which means we need use match keyword to return Some(word) if there is value and None if nothing.

In the case Collection types: we can use the
Array,Vec, Hash etc with iter metod.

use std::collections::HashMap;

fn main(){
    let arr = [1,2,3];
    let v = vec![4,5,6];
    let mut h = HashMap::new();
    h.insert(1,"naveen");
    h.insert(2,"davis");
    h.insert(3,"tom");
    println!("{:?}",arr.iter());
    
    for i in arr.iter(){
        println!("{}",i);
    }
    
    for i in v.iter(){
        println!("{}",i);
    }
    
    for (i,name) in h.iter(){
        println!("{:?}",name);
    }
    
    println!("{:?}",arr.iter().next()); //this is going print only first element
    println!("{:?}",arr.iter().next()); //this is going print only first element
    println!("{:?}",arr.iter().next()); //this is going print only first element
    println!("{:?}",arr.iter().next()); //this is going print only first element
    
    println!("{:?}",h.iter().next());  //this is going print only first element
    println!("{:?}",h.iter().next());  //this is going print only first element
    println!("{:?}",h.iter().next());  //this is going print only first element
    println!("{:?}",h.iter().next());  //this is going print only first element
}

Iter

We can iterate through collection in 3 ways

• iter(), which iterates over &T.
• iter_mut(), which iterates over &mut T.
• into_iter(), which iterates over T.

iterate through immutable reference , in this case we are not supposed to change the value and but we using only reference to value

Rule one: any borrow must last for a scope no greater than that of the owner
Rule two: you may have EITHER 1+ immutable borrows OR EXACTLY 1 mutable borrow

What happens when we compile this code ?
If you have already gone through some Rust program before, you will shout immediately  "compile time" error. As the vector moved in the first for loop and ownership has transfered, so when you try to use it again in the main the value was already dropped. We can use reference to the values to avoid this problem.

True . Rust won't allow to 
fn main() {
   
   let v = vec![3,4,5,7];
   
   for i in v {
      
            println!("{:?}",i);
   }
   
   for i in v {
       println!("{}",i);
   }
   
}

```rust_errors
use of moved value: `v`
  --> src/main.rs:10:13
   |
5  |    for i in v {
   |             - value moved here
...
10 |    for i in v {
   |             ^ value used here after move

In the below example , we solve above problem passing reference to for loop,
You can either use v.iter() or &v

fn main() {
   
   let v = vec![3,4,5,7];
   
   for i in &v {
      
            println!("{:?}",i);
   }
   
   for i in v.iter() {
       println!("{}",i);
   }
   
   println!("{:?}",v);
   
}

If you really want to pass the ownership to the for loop,
use either v or v.into_iter()

fn main() {
   
   let v = vec![3,4,5,7];

   for i in v.into_iter() {
       println!("{}",i);
   }
   
   println!("{:?}",v);
   
}
```rust_errors
 for i in v.into_iter() {
   |             - value moved here
...
11 |    println!("{:?}",v);
   |                    ^ value borrowed here after move
   |
   = note: move occurs because `v` has type `std::vec::Vec<i32>`

Another scenario is you want to update or change the value inside the for loop
you can either pass &mut v or you can use v.iter_mut()

fn main() {
   
   let mut v = vec![3,4,5,7];
   
   for i in &mut v {
      
        *i +=1;
       println!("{:?}",i);
   }
   
   println!("\nsecond iteration to change values\n");
   for i in v.iter_mut() {
      
        *i +=1;
       println!("{:?}",i);
   }
   
   println!("{:?}",v);
   
}

IntoIterator

If you want to use ’ for’ loop in your type, you will need to build the trait IntoIterator for the type.

We will see how to implement an IntoIterator for our type.

Let build a ‘for’ loop for your Struct

How nice it would be if you can do a for loop which iterate through

[derive(Debug)]
struct Sentence{
    words: Vec<String>,
}

impl IntoIterator for Sentence {
    type Item = String;
    type IntoIter = std::vec::IntoIter<std::string::String>;
    fn into_iter(self) -> Self::IntoIter {
        self.words.into_iter()
    }
}


fn main() {

    let sentence = Sentence { 
        words: vec!["one".to_string(), "two".to_string()]
    };
    
    for word in sentence{
        println!("{}",word.contains("w"))
    }
   
}

Standard Output
false
true

In the above example we are creating Sentence Struct which our type. In that we are storing words as Vector elements.

As we discussed in IntoIterator trait implementation, we need to implement the trait for our type Sentence

So two associated types are required ,

one is Item which is the item we are iterating through.
second is IntoIter ie in which type we are iterating through. here it is std::vec::IntoIterstd::string::String

Note: if it were a vector of integers , it would be std::vec::IntoIter

The required method for IntoIterator trait is into_iter which is also implemented with Rust document mentioned parameter and return type.

Trait in rust

Trait in Rust programming

I believe people those who are from object oriented programming languages understand the usage of Trait easily . I have seen people saying Trait are similar to Interfaces in Java.
But we will start with zero perquisites or background knowledge on those. Only prerequisite would be to basic understanding on how “Struct” or user defined data types are created in Rust.

Trait - Collection of methods defined for unknown types.

The definition for Trait is an abstract over behavior that types can have in common.
don’t worry , if we are not able to digest the definition fully.
You might have noticed that in the real world lot of objects shares same behavior and they give the output to the behavior differently.
eg: Car and Bus can provide “ride”
Cat and Dog can have “talk” method
in a Game different objects can have “bonus”
We know these methods/functions are needed for these objects ,but they should produce different output for them differently for different types of objects.
eg : when Cat call “talk” method output would be “Meow Meow”
when Dog call talk method output would be “woof woof”
Also we don’t want other types of objects calling the method if they are not implemented
eg: in my case Cow can’t talk
It would be great if I get noticed in the compile time itself that there is no implementation for Cow for “talk” . rather than future at some point of time in the future the code goes through that piece code and fails badly.
So we can identify the shared behavior of objects in the design phase of your project, the ideal way of defining these common behavior will be through “Trait”
Now you have understood the use case of Trait .
I think we can jump into an example
example creates 3 structs for Cat, Dog and Cow

/*We create/define a trait ( unknown type) using keyword "trait" called Speaker and define the behavior of the trait.
in this example trait accept the unknown type which implements the trait and returns nothing.
Trait name is Speaker and method defined is speak. So we are going to call this "speak" method for  the struct object implements this.
*/

pub trait Speaker {
     fn speak(&self) -> ();
 }

/*Next step would be implementing the trait for whichever types have the common  behavior.
This case our Cat and Dog speaks. 
so implemented them.*/

impl Speaker for Cat { 
 fn speak(&self) { println!("meow!"); }
 }

/* Now we can call them from "main" function as it is in scope.First we need to create struct object and then call the trait defined method (speak) with dot(.) operator. */

cat1.speak();

pub struct Cat{
    color:(u8,u8,u8),
    
}
pub struct Dog{
    color:(u8,u8,u8),
}

pub struct Cow{
    color:(u8,u8,u8),
}


pub trait Speaker {
     fn speak(&self) -> ();
 }



 impl Speaker for Cat {
     fn speak(&self) {
           println!("meow!");
     }
 }

 impl Speaker for Dog {
     fn speak(&self) {
           println!("woof!");
     }
 }
 
fn main(){
    let cat1 = Cat{color:(30,30,30)};
    let dog1 = Dog{color:(30,30,30)};
    let cow1 = Cow{color:(30,30,30)};
    cat1.speak();
    dog1.speak();
    //cow1.speak(); fails in compile time saying "no implementaton of the trait"
}

Trait Bounds
Trait bounds restricts the function to have the types which implements the trait.So the function can not be called with any other types.Code that calls the function with any other type, like a String or an i32, won’t compile, because those types don’t implement "Speaker"

pub struct Cat{
    color:(u8,u8,u8),
    
}
pub struct Dog{
    color:(u8,u8,u8),
}

pub struct Cow{
    color:(u8,u8,u8),
}


pub trait Speaker {
     fn speak(&self) -> ();
 }



 impl Speaker for Cat {
     fn speak(&self) {
           println!("meow!");
     }
 }

 impl Speaker for Dog {
     fn speak(&self) {
           println!("woof!");
     }
 }

pub  fn notify(speaker: S) {
        speaker.speak();
}

fn main(){
    let cat1 = Cat{color:(30,30,30)};
    let dog1 = Dog{color:(30,30,30)};
    let cow1 = Cow{color:(30,30,30)};
    notify(cat1); 
//    notify(cow1); uncomment this line to see the compile time error.
}

In Rust a trait must be in scope for you to be able to call its methods.
Reference
https://doc.rust-lang.org/book/ch10-02-traits.html

Rust macros are Amazing!!!

Macros in Rust programming

Macros are a powerful feature in Rust programming language. Since it is compiled to syntax tree rather than string pre-processing, it has advantages over other language’s macro.

When I started with Rust macro, it was taking me to a new programming style altogether. You can easily convert the reusable part of your program to macros. It is called meta programming .

Declarative Macros

we are going to discuss only this type macro creation in this post.

Macros will try to match pattern passed , if it succeed the match proceed with code defined in curly brackets.

How to start with Rust macro: 

macro_rules! macroname{
 () => { }
}

macro_rules! = is the macro using in rust for creating 


'macro_name' =  is the name you want to be for the macro which can be invoked by *'macro_name!'*

( ) => {}

 () is the sytax for pattern matching 
 {} is the place we need to enter the code to exceuted.
 

($x:expr) 


$x is Name or variable

expr is type to match for name

• ident: an identifier. Examples: x; foo.
• path: a qualified name. Example: T::SpecialA.
• expr: an expression. Examples: 2 + 2; if true { 1 } else { 2 }; f(42).
• ty: a type. Examples: i32; Vec<(char, String)>; &T.
• pat: a pattern. Examples: Some(t); (17, 'a'); _.
• stmt: a single statement. Example: let x = 3.
• block: a brace-delimited sequence of statements. Example: { log(error, "hi"); return 12; }.
• item: an item. Examples: fn foo() { }; struct Bar;.
• meta: a “meta item”, as found in attributes. Example: cfg(target_os = "windows").
• tt: a single token tree.

Macro custom print

macro_rules! print_new{
//in this example we are passing the expression which has only one value which will be stored in $x
 
 //we need to define name and designator 
 // here **$x** is Name or variable
 // **expr** is type to match for name
    ($x:expr) => (
        println!("value={}",$x);
    )
}


fn main() {
    print_new!(5);
}

In rust almost everything is expression .In the above example we passed the ‘expr’ as 5 where 5 designated as name

example 2:
In this example we formatted the pattern as x=> 10+10 which equivalent to x=>$x:expr where $x get the value of 20
macro expression passing


example3:
Here we are passing function name as Identifer to generate/define a function
macro - building function

example4:

macro -apply function to a range of numbers


example5:

macro with pass dentifiers(variables)

Reference

https://words.steveklabnik.com/an-overview-of-macros-in-rust

https://danielkeep.github.io/tlborm/book/index.html

https://danielkeep.github.io/practical-intro-to-macros.html

Sum type with Enum in Rust programming language

Enum - Enumeration

Enumeration as user defined data type and in C programming language its mainly used for names to integral constants .

C syntax: 
Enum state { success = 1, failed = 0 };
Enums has very limited usage in C language. But Rust has used all use cases for Enum and adopted lot of use cases from Functional programming languages like Haskell and ML.
Rust Enum Syntax:
enums are the best example for Sum types. If you want to restrict the input to any one of the types which defined , then they are called some types.

Say you have 'Shape' Type, and you know that shape can be only Circle ,Square or Rectangle. You  want to do action for each types separately. then you can go with Enum.

sum type aslo called Tagged Union, is a data structure used to hold a value that could take on several different, but fixed, types. Only one of the types can be in use at any one time, and a tag field explicitly indicates which one is in use.
The primary advantage of a tagged union/sum type over an untagged union is that all accesses are safe, and the compiler can even check that all cases are handled. 

Enum Shape{
        Circle(f32),
        Square(f32),
        Rectangle(f32,f32),
}





Enum example


Product type:

Struct is good example for product type. As we know, it is required to provide values for each types in a struct . It will be cartesian product of combinations we can make on struct types. It is must to provide value for each for defining an object. 




Importance of enum :

As I mentioned earlier, enum allows to define our own types which increase the readability
of the code as well as reduce the type issues in the programs.

For example , when we know we can only pass our defined type to function and if we can give a meaningful name for that type , which improve strength of the type system in our programs as well as improve the readability of the code.

if parent type consist of different child types, then it will be nice to use them with the hierarchy .Since it is not a product type, you can use one of them from parent at a time. For different type of input can do type validation and perform corresponding action.

Building a Tree DataStructure in Rust programming language

Building Tree data structure gives more understanding on "Struct" and Box pointers in Rust.

Tree data structure is recurrences of Nodes of same Type where each Node normally will have  "value" field and Pointer pointer to the next node.

This is a little challenging to build the Tree in Rust as Rust won't allow to allocate recurring type as their memory space can not predetermined. But we can use  smart pointer BOX for it.

And implementing methods for the 'Tree' will be interesting.

Please find the problem and solution here in github,

https://github.com/davnav/rustgeeks/blob/master/tree_rust.md




Reference: https://matthias-endler.de/2017/boxes-and-trees/

Fundamentals of Webassembly

I was reading more on the WebAssembly last week.wrote about JavaScript in the last post, I don't know whether I have given wrong feeling that we should not study JavaScript at all. I did not meant that.In fact we should study JavaScript to understand more on the internals and browser JS engines .

The only thing I meant , we are in need finding alternative ways for more robust/new languages to replace JS drawbacks.

Web Assembly + Rust can offer some of the replacement for JS drawbacks. read more https://webassembly.org/


I don't know I know good enough to write this post, but still writing..


How to start with Web Assembly + Rust:


You can read webassembly+ rust on  https://rustwasm.github.io/book/why-rust-and-webassembly.html


In Ubuntu Linux machine probably we need the below steps to run webassembly with rust:

1. You need Rust tool chain: rustc, rustup and Cargo   . read the below link for rust tool chain - https://www.rust-lang.org/tools/install


2. wasm-pack - is a one shop for building testing Rust+webassembly applications.
 read about wasm-pack here https://rustwasm.github.io/wasm-pack/installer/

  wasm-pack has prerequisite for  Rust and npm. Since we installed rust in the above step, we only need npm to install ( if you haven't installed)

npm is a package manager for JavaScript. You can install it from https://www.npmjs.com/get-npm


You can get a project template with following ..

Clone a project template with this command:

cargo generate --git https://github.com/rustwasm/wasm-pack-template

you can follow below steps from the document to start with it .. https://rustwasm.github.io/book/game-of-life/hello-world.html




How to access Document elements(DOM ) using Webassembly+Rust

We need wasm_bindgen and web_sys libraries to access the DOM elements with Rust. You can read more about web_sys here -https://rustwasm.github.io/wasm-bindgen/api/web_sys/

Code: lib.rs

extern crate wasm_bindgen;
extern crate web_sys;

mod utils;

use wasm_bindgen::prelude::*;

use wasm_bindgen::JsCast;
use web_sys::{Document, Element, HtmlElement, Window};


#[wasm_bindgen(start)]
pub fn run() {
    using_web_sys();
}


fn using_web_sys()-> Result<(),JsValue>{
use web_sys::console;

console::log_1(&"Hellowrld to console using websys".into());

let window = web_sys::window().expect("no global window exists");
let document = window.document().expect("no document  found");

let body  = document.body().expect("document should have a body");


let val = document.create_element("p")?;

    val.set_inner_html("Hello from 121Rust!");
val.set_attribute("id","p1");
body.append_child(&val);
        let element = document
.get_element_by_id("p2").expect("no p2 element found");

let element1 = document
.get_element_by_id("p1").expect("no p1 element found");


let att = element.text_content().expect("no element text found");

let att1 = element1.text_content().expect("no element text found");
console::log_1(&att.into());

console::log_1(&att1.into());
    Ok(())

}

cargo.toml:

[package]
name = "na-rust-web"
version = "0.1.0"
authors = ["naveen "]

[lib]
crate-type = ["cdylib", "rlib"]


[dependencies]
cfg-if = "0.1.2"
wasm-bindgen = "0.2.29"
#web-sys = { version = "0.3.6", features = ['console'] }

# The `console_error_panic_hook` crate provides better debugging of panics by
# logging them with `console.error`. This is great for development, but requires
# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
# code size when deploying.
console_error_panic_hook = { version = "0.1.1", optional = true }

# `wee_alloc` is a tiny allocator for wasm that is only ~1K in code size
# compared to the default allocator's ~10K. It is slower than the default
# allocator, however.
#
# Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
wee_alloc = { version = "0.4.2", optional = true }

[dev-dependencies]
wasm-bindgen-test = "0.2.29"


[dependencies.web-sys]
version = "0.3.4"
features = [
  'Document',
  'Element',
  'HtmlElement',
  'Node',
  'Window',
  'console',
]
profile.release]
# Tell `rustc` to optimize for small code size.

opt-level = "s"




 

Fundamentals of JavaScript

Last weekend I went to "JavaScript Fundamentals" boot-camp . It was a good class and nice introduction  for people who are new to programming. But my goal was to refresh some of the basics of JavaScript that I haven't tried for long time and want to learn some new things in JavaScript.

Two interesting and new things I learned  from the class are :

1.  80 to 90% of the Internet/Website is running with JavaScript.  Leading browsers in the market ( IE,Mozilla,Google Chrome) can execute only 3 things ( HTML,CSS and JAVASCRIPT).

If you consider Web as language (Analogy), then we can consider  HTML = 'noun' , CSS = "style"  and JavaScript = "Verb". I am ok with this analogy .

All frameworks of other languages like  Django(python web framework) , React( JS framework), Ruby Rails are translating their native language to JS as the browser can  understand only Javascript/html/css.

2. It ( JS applications) can be easily vulnerable and exploited by the malicious  inputs . ( The instructor did not mention/told this ). It was a basic programming boot-camp, so I won't expect him to say this.

But when I saw some of the examples  mentioned are so scary !!!.

We can use "typeof" operator to restrict the input types . But its all on developer's head.

Some of the questions : How  "+" operator can work on number and string ?
It can pass anything to a function and function won't check the type and JS will return something(what ever it like) !!,  its fully developers responsibility to understand the inputs and validate the types of the input before passing.

I think, you can read through below links for more :

https://codeburst.io/top-10-javascript-errors-from-1000-projects-and-how-to-avoid-them-2956ce008437

https://www.pixelstech.net/article/1354210754-10-design-flaws-of-JavaScript

https://whydoesitsuck.com/why-does-javascript-suck/


But I believe, JavaScript is a highly paid programming language and a language still showing/have  deficiency of programmers because 80%t to 90% Websites are running with JS.

If you want to build some fancy and interactive web pages , you need javascript. because the browsers can understand only JavaScript.

That made me research a little bit on Web browser engines, looks like it was just a race for JavaScript engines from 2006 to 2010 between leading web browsers(Microsoft IE, Google Chrome, Opera,Mozilla) . Read more https://en.wikipedia.org/wiki/JavaScript_engine

Just because JavaScript was the only thing making websites interactive and fancy!!. (There would be  some other benefits why browser engines using JS engines). So whoever(browser) can execute the JS quick ,they are the best ( I believe this hold true even today). But serious drawbacks of JavaScript are ignored and that made the internet even worse.

We really need the web to be more secure and trusty , without compromising the performance( I am ok with compromising performance if we get security). So the point is, we really needed an alternative for JavaScript or something can write a good JS for us. Since the 80% of the Web is running with JS, the browsers are not going to switch to some other language engines quickly.

I am not sure how will be internals/architecture  of the browser in next  10 years .I wish there would be more type and memory safe languages engines and they should replace JS engines. People/developers should write those type and memory  safe languages for the browser engines.

I was reading through WebAssembly for last a few months.The JavaScript boot-camp was an eye-opening for me to read more on WebAssembly + Rust again because....

Why  Rust and Web Assembly ?

https://rustwasm.github.io/book/why-rust-and-webassembly.html



WebAssembly -  Its not compromising performance and allows to write type safe + memory safe low languages

Rust - Featuring

• zero-cost abstractions
• move semantics
• guaranteed memory safety
• threads without data races
• trait-based generics
• pattern matching
• type inference
• minimal runtime
• efficient C bindings

But one thing even concerning me is web assembly compiling the C,C++ or Rust to JavaScript that eventually going to run in the browser.. so again JS is going to run in engines. Will this actually solve the JavaScript issues ? I am not sure.


Looking for your comments and thoughts!

Algorithms - sorting algorithms implementation in Rust programming langage

It's important for programmer to do deep dive into algorithms some point of time. but I never tried to do that. As ECE( electronics) branch never needed algorithms in their curriculum, i nicely ignored algorithms . But become unavoidable thing for any kind of application development/programming . its becoming essential to have some ideas or ready made algorithms or approaches in hand to start with some innovative ideas to convert as applications.  So thought of refreshing the algorithms from basics.

If you are learning new language , and trying to solve/implement those basics algorithms , that would be the ideal way to learn them.

And here we are trying to solve/implement some algorithms or problems through Rust programming language.

1. Merge function - https://davnav.github.io/rustgeeks/rust_merge_sortedvectors.html
2.Insert Sort - https://github.com/davnav/rustgeeks/blob/master/rust_insertsort.md
3. Longest string - https://davnav.github.io/rustgeeks/rust_LongestString.html

A new documentation started with Algorithms/problem solutions with Rust programming language

Rust for Geeks:

The problems/algorithms can be Easy,Medium or Hard. If you are newbie to programming , you might have noticed most of the schools/colleges start with “C Programming “ language.

But as an alternative , I would recommend, start with Rust programming language. As you all know C was early computer language and created on 1989. Computer programming languages were evolving over the years.So in a way we can say Rust programming languages evolved over 30 years programming language researches. So its better to start with Rust programming language if you are beginning. But you can learn C/other languages also.

so visit my new github page:

https://davnav.github.io/rustgeeks/

what to do after reading the Rust tutorials !!

if you have read through most of the concepts in Rust and want to build something in Rust, i would suggest below website to start with...

https://mattgathu.github.io/writing-cli-app-rust/

multiple termnial at the same screen - Ubuntu

I started using multiple screen in my office to do multiple tasking. I thought it was not going to save my time  and efficiency. But I experienced that it was highly improving my work efficiency. I was able to finish my tasks quickly without much tiring when doing multi-tasking.

But when i reach home and open the laptop, its highly difficult for me switch between screens.

So I was searching for a tool where i can create multi-terminal on the same screen.

you can use terminator

the installation is simple

apt-get install terminator

open a terminal and type
$terminator 

you will get a terminal open by terminator , then you can split it using ctrl +shift +o

Rust on Amazon EC2

Amazon EC2 is very popular nowadays. So wanted to try something with EC2., not sure how much its going to cost me .Usually I stop amazon experiments when I reach the credit card page. :-)

This time really wanted to try what is EC2.

I took the basic plan and lauched a Ubuntu server and installed Rustc, cargo and gcc.

Its really exciting to login to remote machine and experiment some really  installation and programming as we do in our local machine.