In this blog I will be covering things like:

• DNS servers

  • Resolvers

    • Stub Revolvers

    • Recursive Resolvers

  • root servers

  • TLD servers

  • Authoritative Name Servers

• “is Pi-hole a DNS server or not?”

• “who decides what a URL query like example.com resolves to?”

• “what does it mean when DNS ‘caches’ something?”

• Finally, what is Unbound and how does it fit into all of this?

Buckle up, this is gonna be a long read 😅 With some context and disclaimer out of the way, let’s get reading ! 📖

How the flow of DNS resolution works (the basics)

If you already know about DNS basics, feel free to skip this section.

• Your device asks a resolver: “what is the IP for www.example.com?”.

• If the resolver has the answer cached, it replies immediately with the IP.

• If not, it has to discover the answer by walking this DNS hierarchy:

  • Ask a root server: “who handles .com?”

  • Ask a TLD server: “who handles example.com?”

  • Ask an authoritative server: “what is the record for www.example.com?”

• The resolver caches the answer (for a while) and returns it to your device.
  
  

That’s the whole story. With the IP you get from this your device can then connect to the web server hosting www.example.com. Here’s a quick diagram to visualize this:

Now let’s break down the main players a bit more clearly.

DNS Server

Resolvers

Stub resolver

A stub resolver is the small DNS client on your device (phone, laptop, browser/OS stack).

Its job is simple:

• Take your query (for example, www.example.com)

• Send it to a configured DNS resolver

• Return the response to the app

It usually does not walk the whole DNS tree by itself.

Recursive resolver

A recursive resolver is the one that does the heavy lifting. When you hear someone mention “resolver” in the context of DNS, they are usually referring to a recursive resolver.

already has the answer cached, it responds immediately.

If not, it performs the full lookup process:

• Root server

• TLD server

• Authoritative name server

Then it caches the answer and sends it back to your device. You can see the recursive resolver in the diagram above.

Root servers

Root servers are the starting point of public DNS.

They do not usually know the final IP for www.example.com.

What they do know is: who is responsible for each top-level domain (.com, .org, .net, etc.).

So when asked about www.example.com, the root points the resolver to the .com TLD servers.

TLD servers

TLD (Top Level Domain) servers manage domains under a specific TLD.

For example, .com TLD servers do not know every record for every .com domain, but they know which authoritative name servers are responsible for example.com.

So they return something like: “ask these name servers next.”

Authoritative name servers

Authoritative name servers are the final source of truth for a domain’s DNS records.

This is where records like A, AAAA, CNAME, MX, TXT, etc. are stored.

When the recursive resolver asks for www.example.com, the authoritative server provides the actual answer and a TTL value.

Is Pi-hole a DNS server or not?

Short answer: yes.

But more specifically, Pi-hole is usually a filtering forwarder (a DNS sinkhole), not a full recursive resolver by default.

In practice, Pi-hole does three important things:

• Receives DNS queries from your devices

• Blocks known ad/tracker domains based on blocklists

• Forwards allowed queries to an upstream resolver

So yes, Pi-hole is acting as your DNS server from the client point of view.

However, unless you pair it with something like Unbound, Pi-hole is typically forwarding those queries to another DNS provider (Cloudflare, Google, Quad9, etc.) for final resolution.

DNS caching

DNS caching means: “save the answer for some time so we do not have to ask again immediately.”

The authoritative server includes a TTL (time to live) with each DNS answer.

Resolvers cache that answer for TTL seconds.

If another request for the same name arrives before TTL expires, resolver returns the cached answer.

This improves speed and reduces load, but it also means DNS changes are not visible everywhere instantly.

Caching can happen at multiple layers:

• Browser cache

• OS cache

• Local resolver cache (Pi-hole / router / enterprise DNS)

• Upstream recursive resolver cache

Also, negative results can be cached too (for example, “domain does not exist”), which is called negative caching.

Finally: Unbound and where does it fit?

Unbound is a lightweight, validating, recursive DNS resolver.

If you run Pi-hole + Unbound together, the flow usually looks like this:

1. Device asks Pi-hole

2. Pi-hole blocks or allows query

3. If allowed, Pi-hole forwards to local Unbound

4. Unbound recursively resolves via root -> TLD -> authoritative

5. Unbound returns answer to Pi-hole, Pi-hole returns answer to device

That setup gives you a few nice benefits:

• More privacy: fewer third-party public resolvers in the middle

• More control: your own recursive resolution path

• Local caching: faster repeat lookups

• DNSSEC validation support (when configured), which improves trust in responses

In other words, Pi-hole handles filtering and visibility, while Unbound handles recursive DNS work. They complement each other really well.

Putting it all together with the previous post

In the previous blog, we routed selected devices through Pi-hole using Tailscale.

Now, with this deeper DNS view, that setup should make much more sense:

• Tailscale decides which devices use your private DNS path

• Pi-hole decides which domains are blocked

• Unbound decides how allowed domains are resolved (recursively)

This separation keeps things clean and easy to reason about.

Final thoughts

If you made it this far, you now understand the most important DNS pieces people usually skip: stub resolvers, recursive resolvers, root/TLD/authoritative hierarchy, caching, and where Pi-hole and Unbound fit in.

Once these concepts click, DNS stops feeling “magical” and starts feeling predictable.

And that is exactly what you want when this is powering your home network.

Feel free to reach out if you have any questions or want to discuss further! I hope this was helpful in demystifying DNS and how Pi-hole + Unbound work together.

The main issue is reliability. If your DNS server ever goes down, you’re suddenly stuck without internet access and forced to log into your router to fix things. In my case, that’s especially annoying because my router’s admin interface is entirely in German, with no option to change the language. It’s not a deal breaker, but it definitely adds unnecessary friction. On top of that, routing all your devices through Pi-hole isn’t always desirable. You may not want ad blocking on every single device in your network, right?

This is where Tailscale comes into the picture - and where the blog shifts from being just a “Pi-hole setup” to a “Pi-hole + Tailscale setup.” Instead of modifying router-level DNS settings, Tailscale allows you to selectively route only specific devices through Pi-hole. This gives you fine-grained control over which devices have ads blocked, without putting your entire network at risk if something goes wrong.

High level overview of what we are going to do

Before getting into the setup, here’s a quick overview of what we’re building. Pi-hole will run inside a Docker container on my home server and act as the DNS server. Tailscale will be used to securely connect selected devices to this server, allowing them to use Pi-hole for DNS without modifying any router-level settings.

For some quick context: Pi-hole is a network-level ad blocker. Instead of running inside a browser, it works by blocking requests to known ad and tracking domains at the DNS level. This means ads are filtered out before they ever reach your device, and the blocking applies to all apps and browsers that use DNS, without needing to install anything locally.

Optional: How everything works under the hood

This section is optional and a bit more technical. If you just want to get Pi-hole and Tailscale up and running, feel free to skip ahead to the next section.

If, however, you’d like a deeper understanding of how DNS resolution works, how devices get their network configuration, and how Tailscale and Pi-hole fit into the picture, this section walks through those concepts step by step.

Here is a small sequence diagram that illustrates the flow of DNS requests in this setup for requests that are blocked and allowed by Pi-hole:

DNS

DNS (Domain Name System) is responsible for translating human-readable domain names (like example.com) into IP addresses that computers can communicate with.

Whenever a device wants to access a website, it performs a DNS lookup to determine where that service is hosted. If DNS stops working, most internet access effectively stops as well.

This makes DNS a critical component of any network and also a powerful place to apply filtering and control.

Tailscale

Tailscale is used in this setup to connect selected devices to the home server without exposing anything to the public internet or modifying the existing network configuration.

Under the hood, Tailscale creates a private network between all devices connected to the same account. Each device authenticates using your Tailscale identity, receives a stable Tailscale IP address, and can securely communicate with other devices in that network as if they were on the same local network. Even if they are physically located elsewhere.

Unlike traditional VPNs, Tailscale does not rely on a single central server to route all traffic. Instead, it forms a mesh network where devices connect directly to each other whenever possible. This reduces latency, improves reliability, and avoids unnecessary bottlenecks. From the perspective of the operating system, the connection behaves like a normal network interface.

One of the most useful features of Tailscale in this setup is its DNS integration. Tailscale allows you to define global DNS servers that apply only within the Tailscale network. This makes it possible to override DNS resolution for connected devices without touching router-level settings or affecting the rest of the network.

By pointing Tailscale’s DNS configuration to the home server, only devices connected through Tailscale will attempt to use Pi-hole for DNS. At the same time, fallback DNS servers can be configured to ensure that name resolution continues to work if the Pi-hole service is temporarily unavailable.

In practice, this means you get fine-grained control over which devices use Pi-hole, a stable and secure connection to the home server, and a setup that remains resilient even when parts of it are offline.

Pi-hole

Pi-hole acts as the DNS server for selected devices in this setup, sitting between those devices and the wider internet. Instead of simply resolving domain names, it inspects DNS queries and decides whether a request should be allowed or blocked.

The core idea behind Pi-hole is simple: most ads, trackers, and many malicious services rely on well-known domain names. Pi-hole maintains curated block lists containing these domains. When a device makes a DNS request that matches one of them, Pi-hole responds with a blocking answer, preventing the connection from ever being established. Since the request is stopped at the DNS level, no ad content is downloaded and no client-side extensions are required.

Because this filtering happens at the network layer, it applies uniformly across browsers, applications, and even devices that do not support traditional ad blockers. From the client’s perspective, the request simply fails to resolve.

Pi-hole also provides detailed visibility into DNS activity through its query log. Every request, allowed or blocked, is recorded, making it easy to see which domains devices are attempting to reach. This is invaluable not only for understanding what is being blocked, but also for troubleshooting applications, identifying misbehaving devices, and gaining insight into overall network behavior.

In this setup, Pi-hole becomes more than just an ad blocker it serves as a centralized control and observability point for DNS traffic.

With the background out of the way, it’s time to get our hands dirty and start the actual setup.

Things you will need to install

1. Docker
   Install Docker on your home server.

2. Tailscale
   Install Tailscale on your home server and on the devices you want to use Pi-hole as a DNS server.
   Download link: https://tailscale.com/download
   
   

Setup

We’ll begin with Tailscale, as it forms the foundation for everything that follows. Getting connectivity and DNS routing in place first makes it easier to add Pi-hole and verify each step as we go.

Tailscale setup

We will start by setting up Tailscale before Pi-hole is running. This is intentional and safe, and I’ll explain why later.

Before we begin, this page is where you can see all your connected devices and their Tailscale IP addresses:
https://login.tailscale.com/admin/machines

Now, here’s what needs to be done.

1. Head over to the Tailscale admin DNS settings. You can access it here:
   https://login.tailscale.com/admin/dns

2. In the Global nameservers section, click Add a global nameserver.
   Select Add nameserver > Custom nameserver, then enter your home server’s Tailscale IP address.

   

3. The Tailscale IP address should look something like 100.10.1.12.
   After entering the IP address, click Save.

   

4. Add a second Global nameserver as a fallback.
   You can use Google, Cloudflare, or Quad9—any of them are fine.
   After that, enable the Override DNS servers option.

   

This is all that’s required on the Tailscale side.

At this point, all devices connected to your Tailscale network will attempt to use the Pi-hole server as their DNS server. Since we’ve configured a fallback DNS provider, your internet connection will continue to work even though Pi-hole is not running yet. This is the reason why we set up Tailscale first—it ensures that your devices remain connected to the internet while we configure Pi-hole.

Pi-hole setup

With Tailscale configured, the next step is to set up Pi-hole on the home server.

Pi-hole will run inside a Docker container and act as the DNS server for devices connected via Tailscale. Since Tailscale is already configured to forward DNS queries to this machine, DNS resolution and ad blocking will start working as soon as Pi-hole is up and running.

It is very simple to get Pi-hole running using Docker. Here’s the command you need to run:

Create a docker-compose.yml file and copy and paste the content from this link: https://github.com/pi-hole/docker-pi-hole/#running-pi-hole-docker

You can make modifications to the file as per your requirements in this file. This basically is the configuration file for Pi-hole.

After that, run docker-compose up -d to start the Pi-hole container.

And that’s it! Pi-hole should now be running and ready to accept DNS queries from your Tailscale-connected devices. To check if you can access the Pi-hole dashboard, open a web browser and navigate to http://<HOMESERVER_IP>:<PORT>/admin (if you want to access it from any other device) or localhost:80/admin if you want to access it from the home server itself.

Note: You can use the home server’s Tailscale IP address to access the Pi-hole dashboard from any device connected to your Tailscale network. For example, if you want to access the dashboard from your phone, simply make sure the device is connected to Tailscale. You can then open the Pi-hole admin interface using the server’s Tailscale IP address.

Tailscale IP addresses typically look like 100.x.x.x, so the dashboard would be accessible at a URL like:

http://100.x.x.x/admin

This works because Tailscale places all devices connected to the same account into a private mesh network, allowing them to communicate with each other as if they were on the same local network.

Assigning a static IP to your home server

This is the nice part of the setup. Since we’re using Tailscale, we don’t actually need to assign a static IP address to the home server at the router level.

Tailscale automatically assigns a stable IP address to every device connected to the same account. This IP remains consistent across reboots and network changes, and it’s the address used by our devices when sending DNS queries to Pi-hole. As long as Tailscale is running, the home server is always reachable at the same IP, without any additional router configuration.

Final thoughts

At this point, the setup is complete. We now have a Pi-hole instance running on a home server, selectively providing DNS-based ad blocking to chosen devices via Tailscale—without modifying any router-level settings.

This approach keeps the network flexible and resilient. Devices that should use Pi-hole can opt in simply by connecting to Tailscale, while everything else continues to function as before. If Pi-hole ever goes down, fallback DNS ensures connectivity, and the rest of the network remains unaffected.

More importantly, this setup avoids many of the common pitfalls of network-wide DNS changes. There’s no risk of accidentally taking the entire network offline, no need to fight router interfaces, and no requirement for static LAN IPs thanks to Tailscale’s stable addressing.

From here, there’s plenty of room to extend the setup by adding Unbound for recursive DNS resolution, fine-tuning block lists, or using Pi-hole’s query logs to better understand network traffic. But even without those extras, this configuration already strikes a good balance between control, reliability, and simplicity.

WITH THAT SAY GOODBYE TO ADS! 😉

If this guide helped you, consider experimenting further and adapting it to your own needs. If you run into issues while setting this up or have questions about adapting it to your own environment, feel free to reach out. I’m happy to help where I can and would love to hear how this setup works for you.

So today, I looked it up and thought I’d share what a bastion server is—and what I was initially confusing it with.

🛡️ Bastion Server (a.k.a. Jump Host)

What is a “Bastion”?

A “bastion” is basically a fortified stronghold or a defensive position used to protect a larger area. Something like this.

In the context of IT and cloud computing, a bastion server is a secure entry point for administrators/developers to access internal systems.

Instead of exposing all your servers to the internet, you expose one highly secured machine. Admins/developers first connect to this bastion (usually via SSH or RDP), and from there, they “jump” into private servers that are otherwise unreachable from outside. Think of it as a fortified entry point that admins must pass through to access internal servers. Instead of exposing your entire network to the internet, you expose just this one server. From there, admins can “jump” into the internal systems safely. It’s all about providing a controlled and logged way for humans to do administrative work without opening up your entire environment.

Key points:

• Used mainly by humans (admins, SREs, developers)

• Focused on secure access, not traffic routing

• Heavily hardened and audited

• Common in cloud setups with private subnets

Important: Think of it as a security checkpoint, not a traffic manager.

🚪 API Gateway

This is where my confusion initially came from.

An API gateway is an entry point for application traffic, not admin access. In many microservice architectures, all services are accessible only through the API gateway.

What it typically does:

• Authentication & authorization (users, roles, tokens)

• Routing requests to the correct microservice

• Rate limiting, logging, versioning, etc.

Even though both a bastion server and an API gateway act as “gatekeepers,” they protect very different things:

Bastion → protects infrastructure access

API Gateway → protects application APIs

⚖️ Load Balancer

A load balancer has yet another job:

• Distribute incoming traffic across multiple servers

• Improve availability and reliability

• Prevent any single server from being overwhelmed

It doesn’t care who the user is (that’s auth), and it doesn’t care how admins log in. It just spreads traffic efficiently.

🧠 Simple Mental Model

Bastion Server → “How do admins get into private servers safely?”

API Gateway → “How do users access my APIs securely?”

Load Balancer → “How do I spread traffic across servers?”

Each solves a different problem, and they often coexist in the same architecture.

This was a great reminder for me that similar-sounding components can have very different responsibilities.

Hope this helps someone else who might be mixing these up too 🙂

This post is about replacing Google Photos with something I own and control. I like the experience, but the free tier is too small and I do not want to keep paying for more storage. Google gives you only 15 GB for free, and iCloud is even worse at 5 GB. Amazon Photos offers unlimited photos storage and comes with a Prime subscription, but it only has limited video uploads of 5 GB.

Those tradeoffs pushed me toward a setup that feels like Google Photos, runs on my home server, and is still reachable when I am away. Immich gives me the product, and Tailscale gives me secure access without opening ports to the public internet.

Why this setup

I wanted a self-hosted photo library that feels modern, works flawlessly, and stays secure from anywhere. The combo of Immich and Tailscale delivers that with minimal friction.

What Immich is for

Immich is an open-source, self-hosted alternative to Google Photos. It handles photo uploads from your phone, organizes everything into a timeline, and gives you albums and search without handing your library to a third party. For me, Immich is where all my photos will live going forward.

This is what Immich looks like. It should feel familiar if you use Google Photos, just self-hosted.

Immich web UI showing the timeline and albums.

Basic Immich setup

I will not bore you with every installation detail since it is a couple of commands. Here is the short version I followed, and the official docs are worth skimming for updates.

1. To run immich, you will need to have Docker installed.

2. Download the Immich docker-compose.yml and .env files.

3. Set your photo storage location in the environment file.

4. Start the containers.

mkdir immich && cd immich
wget -O docker-compose.yml https://github.com/immich-app/immich/releases/latest/download/docker-compose.yml
wget -O .env https://github.com/immich-app/immich/releases/latest/download/example.env
# Edit .env to set UPLOADS_PATH to your desired photo storage location
docker compose up -d

Immich quick start guide

What Tailscale is for

Tailscale is for secure remote access. It creates a private network between my devices so I can reach Immich from my phone or laptop when I am away from home. It runs on top of WireGuard, handles device authentication, and keeps traffic encrypted without me touching port forwarding.

If you are new to it, the flow is simple: install Tailscale on the server and your devices, authenticate, and then use the Tailnet IP or MagicDNS hostname to reach Immich.

Tailscale official site

Tailscale is excellent, and the free tier is surprisingly generous.

High-level setup

Here is the simple version of what I did:

• My home server runs Docker and hosts the Immich containers.

• Photos are stored on the server.

• Tailscale runs on the server and on my personal devices allowing me to securely and seamlessly access Immich from anywhere.

[Phone/Laptop] --(Tailscale)--> [Home Server: Immich]

Access path from devices to Immich storage.

My setup details

Use this as a reference and swap in your exact specs:

• Hardware: Beelink (Ryzen 6500U/32GB RAM/1TB SSD)

• OS: WSL2 on Windows (I know I should move to Linux someday, but this works for now)

• Storage layout: Immich uploads on docker volume mapped to my storage path.

Trade-offs vs Google Photos

• You own updates, backups, and uptime.

• Remote access is on you (Tailscale makes this easy).

• The upside is full control and predictable costs.

Backups (do not skip this)

Immich stores photos on disk and metadata in a database, so I plan to back up both:

• The photo storage directory (files).

• The database volume (so search, albums, and metadata are preserved).

A simple starting point is a nightly sync to an external disk plus a weekly copy to an object store like S3 Glacier Deep Archive. Just make sure the database and uploads are backed up consistently.

What I want to improve next

This is the first step, not the final step. My next priorities are automated backups, monitoring, and a clear recovery runbook.

If you are also building a home server, this setup is a great way to make it feel instantly useful. I will keep iterating as I go.

In this write up I will try to give you a brief overview of the terms that you will come across when you are buying a house in Kathmandu, Nepal. I will try to keep it as simple as possible. As usual, if you have any questions, please feel free to reach out. I will try to answer them to the best of my knowledge.

Brokers (दलाल)

When searching for a house to buy, you’ll likely need a broker since finding the right property can be a challenging task. I recommend contacting as many brokers as possible, as most don’t charge buyers for their services—they charge the seller instead. However, it’s important to clarify this with the broker before engaging their services. A great advantage of working with brokers is that they can guide you through the entire process, explaining how everything works. I was fortunate enough to find a helpful broker who assisted me throughout the process without charging me a single rupee. He even negotiated on my behalf with the sellers 😀. If you’d like his contact information, just let me know.

Speaking of negotiating, once you find a house you like and are ready to proceed with the purchase, BARGAIN HARD! If the seller asks for 3 crores, politely counter with a price around 2.50 or 2.60 crores. This gives you some wiggle room. I know it sounds like a big difference, but sellers typically keep a significant margin. Trust me, when you finally agree on a price, you’ll be glad you started low.

Once you’ve successfully negotiated, make sure you do your due diligence. This includes verifying ownership, determining whether the land is guthi or raikad, and understanding the land’s history. You can do this by obtaining a photocopy of the Lalpurja from the owner and visiting the Malpot office, where they’ll provide all necessary information. Additionally, ask for photocopies of the house’s design/maps and consult an engineer to ensure everything is in order. For newer houses built in Kathmandu, you’re generally safe, as construction is only approved after meeting certain criteria (Mapdanda - मापदण्ड).

Remember, there are three critical documents you’ll need to obtain for any house:

1. DPC Completion and Construction Completion Certificate (डीपीसी तल सम्म भवन निर्माण स्विक्रिति पत्र)

2. Construction Permission Certificate (निर्माण ईजाजत पत्र)

3. Construction Completion Certification (निर्माण सम्पन्न पत्र)

Now time to be familiar with some more terms:

Government malpot rate of land (सरकारी मूल्यांकन):

This is the minimum valuation of the land/house set by the government, and it’s often much lower than the actual market value. For example, if the purchase price is 3 crores, the government rate might be less than 70 lakhs. Sellers and buyers typically prefer to use this lower amount in official documents to save on taxes, as the tax on this lower amount is minimal. I’ll explain more about this in the sections on profit tax (लाव कर) and property buying tax (राजस्व).

Thaili rakam (थैली रकम):

This is the amount you show in the documents as the total purchase price, including the token amount. It’s the amount on which you’ll pay taxes to the government. This amount is agreed upon by both the buyer and the seller and can range between the government Malpot rate (सरकारी मूल्यांकन) and the actual purchase price. For instance, if the house costs 3 crores and the government rate is 70 lakhs, you could show 2 crores in the documents, reducing your tax burden. This is a common practice in Nepal.

In my case, I chose to pay taxes on the full amount, and I’d recommend you do the same. This way, you’ll have peace of mind and won’t need to worry about potential legal issues later. Imagine if, years down the line, someone claims the land as part of their inheritance (अंश). Legally, you’d only be entitled to the thaili rakam, not the full purchase price. So, it’s better to play it safe and pay taxes on the full amount.

Profit tax (लाव कर):

This tax is paid to the government at the Malpot office when selling a house, usually by the seller. Currently, the profit tax is 7%, but it’s only applied to the profit, not the total sale price. The higher the thaili rakam, the higher the tax. This is why sellers often prefer to show the government Malpot rate in the documents. However, in Nepal, things are rarely straightforward. Sometimes, sellers might ask buyers to pay the profit tax, so clarify this point before proceeding with the token amount (बैना).

Property buying tax (भवन खरिद राजस्व):

This tax is also paid at the Malpot office when buying a house, usually by the buyer. The tax rate varies depending on whose name the property is being transferred to — 2.5% for senior citizens, 5% for men and 3.75% for women. This is why many people buy property in their grandparents’ names for significant tax savings. Again, this tax is calculated based on the thaili rakam. If the thaili rakam is lower, the taxes are lower too. Please note that these taxes are lower for sub-metropolitan (उप-महानगरपालिका) cities, muncipalities (नगरपालिका) and rural muncipalities (गाउँपालिका) and only apply to Metropolitan cities (महानगरपालिका) like Kathmandu. The taxes are also tad bit lower if the buyer and the seller are relatives.

Before moving forward, I highly recommend watching this video: https://www.youtube.com/watch?v=PVSAyvvHpwk

Baina/Baina batta (बैना बट्टा) (Token amount)

Once you’re satisfied with the house, you can proceed with the baina, a token amount paid to the seller to show your commitment to buying the house. This amount is decided between you and the seller and must be clearly mentioned in a document. This document should be written on Nepali paper (नेपाली कागज) by a lawyer (लेखनदास) and signed by both parties. It’s also essential to have this document verified and signed at the ward office (वडा कार्यालय). This step is crucial, as it serves as proof that the token amount was paid and received, and can help resolve any legal disputes that may arise in the future. Additionally, the government of Nepal has made this verification process mandatory.

The baina document typically includes:

1. Details of the buyer and seller, including their parents’ and grandparents’ names, citizenship numbers, and current addresses.

2. The token amount paid to the seller.

3. The total purchase price of the house, including the token amount. For example, if you’re buying a house for 3 crores and have paid 10 lakhs as the token, the document will show 3 crores, and the remaining 2.90 crores will be paid later.

4. The seller’s agreement to sell the house exclusively to you.

5. The timeframe for completing the sale, usually 35 days, which can be extended if both parties agree.

6. The cheque number and bank name used for the token payment.

7. A clause stating that no further negotiations on the house price will be made.

8. A penalty clause for breaking the agreement, as per the law.

In some cases I have seen token amount (बैना) being returned if the buyer or seller changes his/her mind. However, I have never experienced this myself. Depending on how close you are with the seller, there may or may not be a legal dispute. So it is always better to be cautious and not to pay the baina amount unless you are 100% sure that you want to buy the house.

By the way, let me know if you are looking for a lawyer (लेखनदास). I can recommend you one. He is a nice guy and charges a very small reasonable amount. He helped me with the entire process and I’m incredibly thankful for his help.

Malpot (मालपोत)

Finally, the big day has arrived—the day you’ll officially become the owner of your new house, and the seller will receive the full payment.

You might be wondering how such a large payment is made. The answer is a Good For Payment cheque. This is a regular cheque with additional bank stamps, guaranteeing that you have the funds in your account. The bank freezes this amount, assuring the seller that the money is ready to be transferred to his account. With this guarantee, the seller can confidently transfer the house to your name at the Malpot office and cash the cheque. This method is the most common way to pay for a house, and I recommend getting this cheque a day before your Malpot visit for peace of mind since banks in Nepal can be unpredictable.

Please note that good for payment cheque can be used for any kind of transaction. It is not limited to house buying only.

Here are a few things to prepare before your Malpot office visit:

1. Source of Fund (आयो स्व्रोत): This document proves how you obtained the money to buy the house, whether from stocks, bank loans, salary, or remittance slips. If you borrowed the money from friends or family, you’ll need to get it verified at the ward office (वडा कार्यालय). This process is part of the Department of Money Laundering Investigation (सम्पत्ति शुद्धीकरण अनुसन्धान विभाग) to ensure the money wasn’t obtained illegally.

2. All Heirs/Claimants (हकवाला): Make sure all heirs/claimants are present at the Malpot office along with the seller. This ensures that the house is being sold with the consent of all heirs, preventing potential legal disputes in the future.

3. Baina Document: Bring the baina document with you for verification at the Malpot office. This document is crucial as proof that the token amount was paid and received.

4. Good For Payment Cheque: Bring the Good For Payment cheque to hand over to the seller at the Malpot office. Multiple cheques can be issued in different denominations, as long as they total the thaili rakam. If the actual amount is higher than the thaili rakam, the remaining amount can be paid separately as agreed with the seller.

Once all documents are signed, and your fingerprints are taken, you’ll receive a new Lalpurja with your name on it, usually within a few hours or by the next day.

Congratulations, you are now the owner of the house!

But let me slide in a quick disclaimer: AWS Lambda might not be your first choice for AI tasks.

These AI tasks are resource-intensive and sometimes prefer their tasks to be run on a GPU. But hey, who doesn’t like a bit of challenge and fun?

As we start with this journey, let’s keep few points in our mind:

1. Lambda functions can run for a 15-minute run, MAX. Default is 3 seconds. You might want to configure that.

2. When it comes to using docker containers as lambda functions, they have a “10GB max” size limit. No more. I tried ! :/

3. As of this date, Lambda doesn’t support GPU, so remember this when you’re tinkering around.

Alright, gear up, let’s dive in.

First off, ensure you have docker running on your trusty laptop/PC.

You’ll need three major files to get this show going:

A handler.py file - our command center - looking something like this:

import os
import time
import boto3
import openai
import whisper

start = time.time()
# Load the model outside for a warm lambda executions... Seriously !! This helps !!
model = whisper.load_model("base", download_root='/tmp/')
end = time.time()
print("Time it took Whisper Model to load: ", end - start)

session = boto3.session.Session()
s3_client = boto3.client('s3')
# Security 101: Always keep your secrets ... You know .. SECRETS !! ...
client = session.client(service_name='secretsmanager', region_name='<YOUR_AWS_REGION>')
openai.api_key = client.get_secret_value(
    SecretId='<SECRETIDHERE_SHHH!!>')['SecretString']


def handler(event, context):
    # To run your lambda on a batch, consider iterating the records...
    # My lambda executes when a file is uploaded to a S3 bucket... Tweak this according to your needs ...
    bucket = event['Records'][0]['s3']['bucket']['name']
    key = event['Records'][0]['s3']['object']['key']

    print("Commencing download: ", bucket, key)
    download_path = os.path.join('/tmp', os.path.basename(key))
    s3_client.download_file(bucket, key, download_path)
    print("Done downloading. Wow internet!")
    start = time.time()
    result = model.transcribe(download_path)
    end = time.time()
    print("Transcription time: ", end - start)
    return {
        "statusCode": 200,
        "result": result,
    }

The requirements.txt file - tending to the dependencies:

boto3==1.26.137
openai==0.27.7
openai-whisper==20230314

And last but not least, the Dockerfile - our docker container creator, soon-to-be Lambda function core:

FROM public.ecr.aws/lambda/python:3.10-arm64

RUN yum -y update && \
    yum -y install tar gzip xz && \
    yum clean all && \
    rm -rf /var/cache/yum

RUN curl https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-arm64-static.tar.xz -o ffmpeg.tar.xz && \
    tar -xf ffmpeg.tar.xz && \
    mv ffmpeg-*-static/ffmpeg /usr/local/bin/ && \
    rm -r ffmpeg.tar.xz ffmpeg-*-static

COPY requirements.txt  .
RUN pip3 install -r requirements.txt --target "${LAMBDA_TASK_ROOT}"

# Copy function code
COPY handler.py ${LAMBDA_TASK_ROOT}

# Set the CMD to your handler 
CMD [ "handler.handler" ]

Customize these files to meet your requirements, and voila! You’re ready to launch your code into the AWS Lambda.

Unleash the Deployment !!

Kick things off by building the docker image:

docker build -t image-name .   

To check if your creation is functioning as expected, put it through a local test run:

docker run -p 9000:8080 image-name 

And hope it works:

curl -XPOST "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'

At this point, your terminal should return you with an output.

Your docker image, now ready and waiting, needs to be uploaded to ECR (Elastic Container Registry) for its Lambda adventure.

To do this, you’ll need an ECR repository. If you have one, use it by all means. If not, create an ECR repo with this command:

aws ecr create-repository --repository-name docker-image-ecr-repository --region <YOUR_AWS_REGION> --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE

Your terminal will reward you with a response like this. COPY that repositoryUri. We’ll need it to upload our docker image to the repository:

{
    "repository": {
        "repositoryArn": "arn:aws:ecr:<YOUR_AWS_REGION>:XXXXXXXXXX:repository/docker-image",
        "registryId": "XXXXXXXXXX",
        "repositoryName": "docker-image",
        "repositoryUri": "XXXXXXXXXX.dkr.ecr.<YOUR_AWS_REGION>.amazonaws.com/docker-image",
        "createdAt": "2023-03-09T10:39:01+00:00",
        "imageTagMutability": "MUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": true
        },
        "encryptionConfiguration": {
            "encryptionType": "AES256"
        }
    }
}

But wait, there’s more! Before you can upload the images to the repository, you need to prove your identity. Authenticate by executing this:

aws ecr get-login-password --region <YOUR_AWS_REGION> | docker login --username AWS --password-stdin <YOUR_AWS_ACCOUNT_ID>.dkr.ecr.<YOUR_AWS_REGION>.amazonaws.com

Just one more teeny step. To guide it to the right ECR repository, you need to tag your docker image with the repository name, like so:

docker tag docker-image:latest <YOUR_AWS_ACCOUNT_ID>.dkr.ecr.<YOUR_AWS_REGION>.amazonaws.com/docker-image-ecr-repository:latest

Trust me !! this is the final step! Now it’s time to push the image.

docker push <YOUR_AWS_ACCOUNT_ID>.dkr.ecr.<YOUR_AWS_REGION>.amazonaws.com/docker-image-ecr-repository:latest

With your image now in ECR you are ready to deploy it to AWS Lambda. Here, you have a lots of choices. You can create lambda functions from the console or from tools like AWS SAM, CDK, Terraform, and more.

As always, if you hit any roadblocks or need some guidance, don’t hesitate to give me a shout.

Happy Coding!

For those looking to explore these two options, here are the links and instructions for getting started:

AWS CodeWhisperer

To begin with AWS CodeWhisperer, first install the AWS toolkit. Once the installation is complete, navigate to the sidebar, select the AWS toolkit, and click on CodeWhisperer. Simply follow a series of user-friendly steps, and the coding assistant will be up and running in no time.

Codium

To start using Codium, install the extension via the link https://codeium.com/vscode_tutorial. Upon completion, you will be prompted with a login popup. After the login, you’re all set to experience the benefits of Codium.

Allow me to cut to the chase and highlight the advantages of Codium over CodeWhisperer, which makes it the preferable choice for many developers:

• The autocomplete/suggestions in Codium are far more advanced. They exhibit a higher level of understanding, better grasping developers’ intentions and rarely suggesting irrelevant or nonsensical code snippets. This is where I found CodeWhisperer to be very annoying. It seriously has a long way to go.

• Consistent updates from the developers ensure that Codium stays at the forefront of the rapidly evolving AI. With new features and fixes being released almost daily, I think this it is getting better daily.

• Codium provides an intuitive set of option displayed above each function, adding a layer of convenience and ease for users. However, for some it might take a while to get used to. Here’s an example:

Moreover, Codium boasts an impressive array of features that cater to a variety of users and development environments.

1. It integrates seamlessly with a wide range of IDEs, including VSCode, JetBrains, IntelliJ, Jupyter / Colab / Deepnote / Databricks Notebooks, Chrome, Vim / Neovim, Emacs, and VSCode Web IDEs (e.g., Gitpod).

2. With support for an extensive list of 70+ programming languages, Codium has more capabilities than other code assistants on the market. It also has better support for languages than Github Co-pilot.

3. Users can rest assured that their code remains private, as it is not utilized to train models or for any other purpose. The developers maintain a strict policy against training generative models on private codebases.

Although Codium has a clear edge, CodeWhisperer does possess two intriguing features: the code scan feature, which identifies potential bugs and vulnerabilities, and the cmd+c shortcut trigger for code completions.

Looking ahead ….

There is another prominent contender in the coding assistant arena: GitHub Copilot. Hearning significant praise from developers on platforms like Twitter and Reddit, it boasts low-latency code completions, even in complex scenarios. I start working with it from tomorrow. Hopefully it does not fall short to amaze me :D

As always, I welcome any questions or suggestions you may have. Don’t hesitate to reach out and continue the conversation.

Google Calendar

I am pretty much sure that most of you might already have this app. For me, google calendar works like a reminder, todo app and a calendar app (obviously) all in one. I have tried apps like Fantastical, BusyCal, iCal, Todoist and many others but I always kept coming back to google calendar. For someone like me who keeps forgetting things, there is a widget that google calendar provides and it works wonders.

Bitwarden

And again, for someone who forgets literally everything, remembering multiple passwords for different accounts is next to impossible. This is where bitwarden comes in handy. It helps users generate and store strong passwords securely, making it easier to manage and remember them.

Bitwarden is an open-source password manager in which data is encrypted locally before being synced with Bitwarden’s servers. Bitwarden uses two-factor authentication and alerts users of any suspicious login attempts, making it a highly secure option for password management. Great thing is, it’s cross-platform and especially in iOS the autocomplete works really well.

Apple books

I assume people are going to hate me for this but surprisingly Apple books has been working pretty great for me. I know that the app is pretty basic and has a long way to go when it comes to competing with other apps. But, there is this one feature it offers that I just can’t find anywhere which is importing any epub files from the internet.

I just download books from the internet in epub format and upload them to Apple books. The notetaking and highlighting feature is also good. Plus, it takes care of syncing, which means I can read it on my tablet, laptop and mobile pretty smoothly.

Buffer

I do not use this app a lot but I think this serves it’s value. This app allows you to schedule your post to certain social media sites. You can share to instagram , twitter, LinkedIn and many other platforms at once just by setting up a posting schedule. Want your post to be posted in different platforms at 6am tomorrow morning? It’s simple now.

Deepstash

This is one of those apps that give you short and concise ideas. The UI is very intuitive and clean.

Hacker Feed

This one would be perfect for those who are interest in tech. I personally use this to find amazing github repositories that are eye catching.

Matter

This is one of the best apps the I found last year. It let’s you save things that you want to read for the future. The reader is clean and elegant. It has amazing highlighting features and this is one of those app which I think should be paid, but is not. There is a chrome extension also which lets you highlight and save pages to read in the future.

Notion

I don’t think I need to say a word regarding this app. The app allows users to create different types of pages, including databases, notes, calendars, to-do lists, and more, all of which can be customized to fit their unique needs. It’s like having functionalities of various apps like Trello, Evernote, and Google Docs into one. I love the widget too.

Raindrop.io

This is one of those apps that I found after lots and lots of searching around. I was looking for an app that would save my links in an orderly fashion. This app does exactly that and so much more. This app also has a browser extension that has been super helpful for me in recent days. Definitely worth trying.

Reddit

Sorry, we can’t be friends if you do not use reddit. There is something for everyone. Select a field you are interested in and get posts about the latest and greatest topics. No wonder it is called “The Front Page of The Internet”. Go install !! RIGHT NOW !!

Splitwise

This app is a must-have if you have friends like mine. Yeah, you know who you are guys :D Splitwise allows you to keep track of shared expenses with friends, family, or roommates. It simplifies the process of splitting bills and helps to avoid awkward situations by keeping a record of who owes what.

Why is this necessary?

• Get a bank account easily.
  However, there are workarounds which I have mentioned in my other blog.

• Get a resident card/blue card.
  Depending on where you come from you would most probably have a temporary D-type visa for 3 months to 6 months. For living in Germany for a longer duration you will need to convert that to a resident permit.

• Get a Sim card easily.
  Again, there is a simple workaround for this as well which I have mentioned in my blog as well.

• Get tax ID.
  This one is automatically done on your behalf from the city office/registration office. You will get your tax ID in your mailbox which you should be providing to your employer in order to pay taxes. As far as I know, there is nothing to be done from your end here.

Before you get to this step you will need the following things:

• You can only get to this step after you find yourself an apartment/living place where the landlord can provide you with an apartment confirmation document called Wohnungsbestätigung.
  Please note that hotels, Airbnb and some landlords do not provide this. You will need to keep this in mind when getting an apartment.

• Obviously, you will need a valid passport and the temporary visa (the D-type visa) that got you to Germany in the first place.

A small note here. There is an anmeldung form available online too but I did not need to fill that up. The lady in the city office filled it up for me during the appointment time. Depending on where you book your appointment you will have an English speaking on the other end.

Here’s a PRO TIP: If it is possible, take someone who can speak German with you. I did the same and things got way wayyy easier because of him.

Here is what I did and how it went.

• Book an appointment online from this link.
  After you book it you will get an email with a number. For me, it was: T390.

• Go there on time and wait for your number to be called on the screens. Then head to the section you are called to and you should have your anmeldung/registration done in the next 10 mins.

My overall experience was super nice. The process was very fast. Way faster that I expected it to be. The lady in the office was also super nice and super kind. She spoke to me very politely and in english. There was no hesitation from her side when providing me the final anmeldung document.

First, please let me introduce him.

Jagatjyoti is a very humble person and a keen tech enthusiast. Like me, he believes in networking and is open to connecting with people who share common interests. He started his journey with Designco Nepal and is currently working on Fusemachines as a Senior Software Engineer for 4.5 years. Also, we both graduated in Computer Science and Engineering from India. He has expertise in Full stack development JavaScript / Typescript and is interested in keen blockchain, data science, and mobile development.

Here is his LinkedIn profile if you want to connect with him: https://www.linkedin.com/in/jagatjyotig/

I asked him many questions, but I will try to include only relevant ones that make sense to keep this blog short.

Fusemachines is one of the leading IT companies here in Nepal. How did you get in? Do you feel proud of that?

“Indeed, I do feel proud. Taking ownership of projects and optimally delivering them is what thrives and inspires me. I find that very interesting, and I am learning a lot too. I was asked by a friend who suggested I drop my CV here. My interviews were extensively technical, and I was honestly very nervous. I remember I started with Node and Ember JS projects.”

I heard from a close friend that Fusemachines conducts a Knowledge Sharing session every week to learn and research new things. Is that true?

“Yes, it is. Fusemachines as a company is extensively research-driven so having Knowledge sharing sessions enhances everyone’s ability to research and learn new things. Plus, we are an AI-based company, and R&D is the heart here.”

Do you think data Structures and algorithms are important for full-stack developers?

“I think it is an absolute requirement because, behind the scene, everything is based on it. These days, frameworks have made life easier, but you should know the internal workings of the framework as a software engineer. This also is true for machine learning engineers because even though there are packages readily available, what separates you the most is your understanding of how things work in the background. In general, it helps you make robust decisions. People usually ignore it, but I would say this is very, very important.”

How do you handle the project’s code when there are more than a dozen people working?

“We try to maintain coding standards as much as we can. We help each other to lean towards better practices. On personal levels we use linters and each pull request goes through two other developers which only gets accepted if that section makes sense. Test cases much exist and there are few other practices that one should abide by. I personally feel this is very important because this indeed will help future contributors to be comfortable with the codebase faster. But, this is also one of the trickiest things to get right. Maintaining constraints for 70-80 engineers is a very difficult job to do. Efficiency and best practices are two vital components for us.”

What India has for college students?

I would like to introduce something out of the blue here which is very prevalent in India. India has a lot of companies and a lot of engineers. To fill the demand and supply gaps, the companies there have kind of a partnership with the colleges. These are also called “College Placements”. This means you will have a job in your hands right when you graduate. This was the case for me too. In fact, I joined Codemantra 2 days after my final exams. These days placements of some companies are very lucrative to be honest. Given the right skillset, some were placed at 25+ Lakhs per annum this year from several tier A colleges.

How is the salary here in Nepal, especially for Software Engineers?

“I have a non-disclosure agreement that forbids me to talk about my salary, but in recent years the IT field has shown good growth, and the salary levels have also seen substantial increments. However, the fluctuation is huge and can widely vary.”

Similar is the case in India too. The IT field has seen enormous growth, and the salary ranges also vary from place to place. I have seen people getting 40+ lakhs per annum with ~4 years of experience and I personally have worked with people with ~10 lakhs per annum with the same experience. So, yes, the margin varies widely. There is a trend going in India these days. Startups that have secured some funding are paying really well to the developers compared to India’s tech giant. For example, Cred and Swiggy pay way more than TCS, Wipro, etc.

Since we are talking about salary, with that comes tax too. I have worked in India, and I understand what tax deductions you can avail of, but unfortunately, I have no clue about the structure and beliefs here. Please let me know if you can help. I hear that the tax deduction system in Nepal is messed up, and nobody really provides a clear answer. For example, in India, we can claim tax deductions by investing in mutual funds. Can we do that here too?

Please let me know if you want to know about the salary ranges for different places. I will try to write another blog and refer to sites with all this information.

What are your views on cryptocurrencies?

“I believe in the concept of cryptocurrencies and the underlying tech that it runs on. In fact, in my free time, I research it and try to learn new stuff. I think that the power should be in the general public’s hands. With that said, there are scams like pump and dump happening worldwide, and some coins are just trolls. I assume that the future is bright for this, but the road is bumpy.”

What would you suggest to a beginner who is just starting out or is a fresh college graduate?

“My main tip would be - Do not just copy and paste code from GitHub or StackOverflow but try to understand what that code does as well. Be aware of what happens behind the scene. A developer needs to know what the code does. Do not just run after results but make sure you understand what you did to get the result (The final thing that works). Also, another thing you should do is, get your basics cleared in your college days and have something to show. Do not run after companies and think that you will learn whatever is needed when you get in. Companies these days are looking for interns who have done something by themselves before. If you have something to show, then that really makes you stand out from the crowd.”

I couldn’t agree more on this. Taking my example here, before graduating, I had a bunch of projects to show off to companies that really made a good impression on me. I had projects in blockchain, PHP, react, and a few other things, including my portfolio. This, till today, gives me a head start when reaching out to companies or impressing someone in the community.

I would like to bring this blog to an abrupt stop as it is getting lengthy. It is quite hard to summarize a 2-hour long call, honestly.

As usual, please reach out if you want to talk tech. I love to network and connect with people.

It is a clean and nice looking terminal, isn’t it? As a guy who works with code nearly all the time, this place should be very familiar to you.

Why would you want this?

Trust me, you do. It looks aesthetically pleasing and clean. If you are like me, then terminal shells like this will make you want to use it more, making you more productive.

Shut up and get to the point. How do I get this installed?

Ok. Before we start I would strongly recommend you to download some of these fonts because windows default fonts sucks and, these are the ones that support the icons and ligratures really well.

DOWNLOAD NERD FONTS

Note: You do not need to download all these fonts. Just download the one you want and install it. All you will need to do is extract the .zip and double click on the font files to install it.

Done? Good. Now,

The page that I am referring is here (oh-my-posh). Feel free to jump there if you are confident to install it. I will walk you through the installation steps anyways. I highly suggest you to use Windows Terminal as it is amazing and any further customization is a piece of cake. You will need either winget (is an awesome package manager for windows, try it out if you have not yet!) or scoop (similar to winget, but older?). I will be using winget, but the process is exactly the same for scoop too. For the future readers, you might want to see if your windows already has winget installed, as Microsoft will be shipping winget by default in all Windows machines soon.

Install oh-my-posh:

winget install JanDeDobbeleer.OhMyPosh

Then, open your Powershell and follow the steps below (Remember, it has to be powershell or else it will not work).You will need to add a single line to a file here.

notepad $PROFILE

and add the below line to the file. If you already have some text in that file then add this line to the bottom of the text. Also, remember to replace [PATH] with the path to that json file. It should be under ~\AppData\Local\Programs\oh-my-posh\themes\ for almost everyone.

oh-my-posh --init --shell pwsh --config [PATH]/jandedobbeleer.omp.json | Invoke-Expression

now the final step is to reload the shell:

. $PROFILE

and you’re done.

By default there are a bunch of themes that this tool provides but I prefer to customize it further and make my own adjustments. You can download my custom theme from here (prameshbajra github). Simply download this json and place it along with with jsons inside folder : ~\AppData\Local\Programs\oh-my-posh\themes\.

You must also edit this line to:

oh-my-posh --init --shell pwsh --config [PATH]/pramesh.omp.json | Invoke-Expression 

and do:

. $PROFILE

You can have a look at the whole list of themes here.

Enjoy your new theme.

Oh wait, one more thing,

The customizations you make here will also be applied in VSCode integrated terminal. So it is definitely a win-win.

As always feel free to reach out if you have any queries. I love talking tech anytime.

Serverless, I choose you.... But, why?

I did it simply because I wanted to learn. Learning exiciting new stuffs and writing about them has become my niche these days. My motive aside, there are several good things that serverless brings to the table. The most important being the cost saving features. If you are a company that caters thousands, if not millions of users, then this might be a ground breaking thing but for me, this was not the main reason.

I went with serverless because it auto-scales without additional work. While, it is fun to come up with system architecture where everything is implemented in house, it sometimes becomes tedious if you just want you go live and make things work. Some other points that I love about serverless are:

• it scales with demand automatically

• it significantly reduces server cost (70-90%), because you don’t pay for idle

• it eliminates server maintenance

• it frees up developer resources to take on projects that directly drive business value (versus spending that time on maintenance)

Let's talk about the application - How to use it?

You can simply head over to Youtube Download - Bazra to have a look for it yourself. The site is very simple (My 12 year old brother was able to figure out how to download the videos without guidance).

So, first thing first, right after you visit the site you will see a place to enter a link for the video you want to download from YouTube. If you are from a laptop/computer, you can simply copy the link from the top address bar and paste it in the site and hit enter (or click download). If you are from a mobile you can share the video and copy the link (either way, it works) and paste it into the site and download it.

Done! Your video will be downloaded. Simple, isn’t it?

This is the first version release. After you click download the video will be downloaded in the highest resolution available.

Technicalities - How it was build

I have used the following:

• AWS (Amazon web services)

  I use AWS to host all my backend code. The core services I use are: Cloudfront (fast content delivery network (CDN)), S3 (to save videos and host this site), Lambda (backend code), Cloudwatch (for logs). Let me know if you want to get started with AWS too. I can set up an account for you. I have couple hundred dollars lying passive here.

• Serverless Framework

  This is an awesome framework to which I should provide a .yml configuration file and it will setup all the infrastructure in any cloud provider (in my case AWS). There are plugins involved as well.

• Angular 10

  It is another amazing platform for building mobile and desktop web applications.

• Python 3

  Programming language of my choice. I use packages like boto3, pytube etc.

• Docker

  This deserves a whole long blog post on itself. But, just for this application it is needed to bundle python dependencies to deploy it as lambda functions on aws.

If you are already familiar with these then you can hop to my github repository where all the code is present. If you are interested, I would love to have contributions.

Please text me, or get in touch through any medium if you would like to discuss more on it. I love tech gossips.

GITHUB: Youtube Downloader - Bazra

Future Plans

1. I will be updating this site next weekend with more features like video download based on resolution you select. Good news! The backend is already done.

2. Then, I will also be adding an audio download feature where you can just give the youtube URL and audio file will be downloaded instead of video.

3. I will be adding a contributors page and a documentation page as well.

4. I have lot of interest in creating a browser extension as well, but let’s see where this goes.

5. There might be ads later. Maybe after some user traffic? Also, I will be using the money to donate to some good cause. The infrastructure will be handled by me as long as it is under my budget.

6. This is not yet decided but, I will be publishing the APIs for free and will provide a concise documentation.

As always, I would love to hear back. Feel free to drop suggestions and also let me know what I should add? My emails and messages are always open. And, there is a comment box below if in case you did not notice. :P

Ok then, with that out of the way. Let’s talk python today. This is my first time looking and using the latest features provided by any programming language other than JavaScript and honestly, I am very impressed.

Let's jump right in

To make things easier I will be ignoring all the other additions that I did not find very interesting. I mean, I will only mention those latest features which I think will be worth mentioning and will be of some use to us developers.

1. The union operator for dictionaries (| and |=)

   In earlier versions, to merge 2 dictionaries you would do something like:

    python = {2000: "2.0.1", 2008: "2.6.9", 2010: "2.7.18"}
    python3 = {2008: "3.0.1", 2009: "3.1.5", 2016: "3.6.12", 2020: "3.9.0"}
   
    ##merging two dictionaries
    {**python, **python3}
   
    # or
    python.update(python3)
   

   But, now you can simply do

    ##merging two dictionaries
    python | python3
   
    # and update dictionary
    python |= python3
   

   both of the above code will update python dictionary to

    {
        2000: "2.0.1",
        2008: "3.0.1",
        2010: "2.7.18",
        2009: "3.1.5",
        2016: "3.6.12", 
        2020: "3.9.0"
    }
   

   Pretty sleek, don’t you think?

2. removeprefix() and removesuffix() FINALLY !!!

   I do not know about you, but this is a must have for me. I personally, have to work with many file operations where saving a file with new name is a common job.

   In Python 3.9, there are two new string methods that solve this exact use case. You can use .removeprefix() and .removesuffix() to remove the beginning or end of a string, respectively:

   # In older python code:
   document_file_name = "pramesh.pdf"
   json_file_name = f"{document_file_name.split(".")[0]}.json"
   
   # In python 3.9, I can just do:
   document_file_name = "pramesh.pdf"
   json_file_name = f"{document_file_name.removesuffix(".pdf")}.json"
   

   Much clear, isn’t it?

3. math.gcd() and math.lcm() now works with list of numbers.

   Earlier, you could do this

    import math
    # This worked ...
    print(math.gcd(49, 14)) # 7
   
    # But this did not ...
    print(math.gcd(273, 1729, 6048)) # 7
   

   Now, wahh laaa!! The second one works too. And, same thing applies to LCM as well. You will now be able to use these functions as

    print(math.gcd(273, 1729, 6048)) # 7
   

4. zoneinfo

   The zoneinfo module brings support for the IANA time zone database to the standard library. It adds zoneinfo.ZoneInfo, a concrete datetime.tzinfo implementation backed by the system’s time zone data.

    >>> from zoneinfo import ZoneInfo
    >>> from datetime import datetime, timedelta
   
    >>> # Daylight saving time
    >>> dt = datetime(2020, 10, 31, 12, tzinfo=ZoneInfo("America/Los_Angeles"))
    >>> print(dt)
    2020-10-31 12:00:00-07:00
    >>> dt.tzname()
    'PDT'
   
    >>> # Standard time
    >>> dt += timedelta(days=7)
    >>> print(dt)
    2020-11-07 12:00:00-08:00
    >>> print(dt.tzname())
    PST
   

   
   

These were some of the cool features that I liked in this new version of Python. There are many others too. Please refer to RELEASE NOTES if you want to dig deeper and have a look for yourself.

What's next?

I just wanted to point out some minor things here that needs to be kept in mind when working with Python.

Python 2 has been unsupported from the Python Community for a while now. Python 3.9 is the last version providing those Python 2 backward compatibility layers, to give more time to Python projects maintainers to organize the removal of the Python 2 support and add support for Python 3.9. So, from next version onwards buckle up for some breaking things.

Python 3.9 uses a new parser, based on PEG instead of LL(1). The new parser’s performance is roughly comparable to that of the old parser, but the PEG formalism is more flexible than LL(1) when it comes to designing new language features. We’ll start using this flexibility in Python 3.10 and later. The ast module uses the new parser and produces the same AST as the old parser. In Python 3.10, the old parser will be deleted and so will all functionality that depends on it (primarily the parser module, which has long been deprecated). In Python 3.9 only, you can switch back to the LL(1) parser using a command line switch (-X oldparser) or an environment variable (PYTHONOLDPARSER=1).

Fingers crossed for Python 3.10 now.

As usual, feel free to drop a message if you want to get in touch. I am always ready to talk tech.

with any Angular related work you will need to have Node and the Angular CLI in place. If you do not then head over to the below links to install them.

1. Node (will come with npm - node package manager)

2. Angular CLI

I’m guessing that you already have an Angular project in place. This method should work with all versions of Angular that came after 2.

In case if you do not have an Angular project, then you can create it using:

ng new <project_name>

You will be prompted with a bunch of necessary questions where you can select necessary configuration for the project to be created.

For the demo purpose, I created a new Angular project named: aggrid-angular You can find the code at my github:

prameshbajra/aggrid-angular

Starting with ag-grid

Before diving into the code, I would like to give a brief introduction on ag-grid and why I like it so much.

The “ag” part of ag-Grid stands for “agnostic”. People claim that this package is the best JavaScript Grid in the world. It is packed with lots of features and is a child’s play to use, that too without any compromise in the performace. They provide highly performant, scalable tables with almost unlimited features. And guess what? …. It is totally FREE !!!

On to the code

Start by installing the library itself.

npm install --save ag-grid-community ag-grid-angular
npm install 

Let’s get to the actual coding! As a first step, let’s add the ag-Grid Angular module to our app module (src/app/app.module.ts):

import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';

import { AppComponent } from './app.component';
import { AgGridModule } from 'ag-grid-angular';

@NgModule({
  declarations: [AppComponent],
  imports: [
    BrowserModule,
    AgGridModule.withComponents([])
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule {}

The next step is to add the ag-Grid styles - replace the content of styles.scss with the following code:

Note: If you are under an existing Angular project then consider adding these.

@import "../node_modules/ag-grid-community/src/styles/ag-grid.scss";
@import "../node_modules/ag-grid-community/src/styles/ag-theme-alpine/sass/ag-theme-alpine-mixin.scss";

.ag-theme-alpine {
    @include ag-theme-alpine();
}

The code above imports the grid “structure” stylesheet (ag-grid.css), and one of the available grid themes: (ag-theme-alpine.css). The grid ships several different themes; pick one that matches your project design. You can customise it further with Sass variables too.

Next, let’s declare the basic grid configuration. Edit src/app.component.ts:

import { Component, OnInit } from '@angular/core';
import { HttpClient } from '@angular/common/http';

@Component({
    selector: 'app-root',
    templateUrl: './app.component.html',
    styleUrls: ['./app.component.scss']
})

export class AppComponent implements OnInit {
    title = 'app';

    columnDefs = [
        {headerName: 'Make', field: 'make', sortable: true, filter: true},
        {headerName: 'Model', field: 'model', sortable: true, filter: true},
        {headerName: 'Price', field: 'price', sortable: true, filter: true}
    ];

    rowData: any;

    constructor(private http: HttpClient) {

    }

    ngOnInit() {
        this.rowData = this.http.get('https://raw.githubusercontent.com/ag-grid/ag-grid/master/grid-packages/ag-grid-docs/src/sample-data/smallRowData.json');
    }
}

The above code turns the rowData from a hard-coded array to an Observable. For the grid to work with it, we need to add an async pipe to the property:

<ag-grid-angular
    style="width: 500px; height: 500px;"
		class="ag-theme-alpine"
		[rowData]="rowData | async"
		[columnDefs]="columnDefs">
</ag-grid-angular>

Just with these simple steps you can now see the table rendered in the UI. Try dragging the columns around. Nice, right? These are all the features that ag-grid provide out of the box.

Why stop here? Let’s keep adding some more stuffs

Enable Sorting And Filtering

Well, enabling sorting in ag-Grid is actually quite simple - all you need to do is set the sortable property to each column you want to be able to sort by. Easy isn’t it?

Click on the column heads to sort accordingly.

columnDefs = [
    {headerName: 'Make', field: 'make', sortable: true},
    {headerName: 'Model', field: 'model', sortable: true},
    {headerName: 'Price', field: 'price', sortable: true}
];

As with sorting, enabling filtering is as easy as setting the filter property:

columnDefs = [
    {headerName: 'Make', field: 'make', sortable: true, filter: true},
    {headerName: 'Model', field: 'model', sortable: true, filter: true},
    {headerName: 'Price', field: 'price', sortable: true, filter: true}
];

Multi Level Header Table

This was honestly the most tedious part of making tables in angular using libraries. No other library (including angular-material) provides an easy way of implementing multi header functionality. All thanks to Ag-grid, you can now do this with very minute change.

I will be creating a new component for this. It can be done by:

ng g c app/multi-header

Inside the new component you can have the below html.

<ag-grid-angular #agGrid style="width: 1200px; height: 600px;" id="myGrid" class="ag-theme-alpine"
    [columnDefs]="columnDefs" [defaultColDef]="defaultColDef" [debug]="true" [rowData]="rowData"
    (gridReady)="onGridReady($event)"></ag-grid-angular>

and in the respective typescript component file you can have this:

import { HttpClient } from '@angular/common/http';
import { Component } from '@angular/core';

@Component({
    selector: 'app-multi-header',
    templateUrl: './multi-header.component.html',
    styleUrls: ['./multi-header.component.scss']
})

export class MultiHeaderComponent {
    private gridApi;
    private gridColumnApi;

    private columnDefs;
    private defaultColDef;
    private rowData: [];

    constructor(private http: HttpClient) {
        this.columnDefs = [
            {
                headerName: 'Athlete Details',
                children: [
                    {
                        headerName: 'Athlete',
                        field: 'athlete',
                        width: 180,
                        filter: 'agTextColumnFilter',
                    },
                    {
                        headerName: 'Age',
                        field: 'age',
                        width: 90,
                        filter: 'agNumberColumnFilter',
                    },
                    {
                        headerName: 'Country',
                        field: 'country',
                        width: 140,
                    },
                ],
            },
            {
                headerName: 'Sports Results',
                children: [
                    {
                        headerName: 'Sport',
                        field: 'sport',
                        width: 140,
                    },
                    {
                        headerName: 'Total',
                        columnGroupShow: 'closed',
                        field: 'total',
                        width: 100,
                        filter: 'agNumberColumnFilter',
                    },
                    {
                        headerName: 'Gold',
                        columnGroupShow: 'open',
                        field: 'gold',
                        width: 100,
                        filter: 'agNumberColumnFilter',
                    },
                    {
                        headerName: 'Silver',
                        columnGroupShow: 'open',
                        field: 'silver',
                        width: 100,
                        filter: 'agNumberColumnFilter',
                    },
                    {
                        headerName: 'Bronze',
                        columnGroupShow: 'open',
                        field: 'bronze',
                        width: 100,
                        filter: 'agNumberColumnFilter',
                    },
                ],
            },
        ];
        this.defaultColDef = {
            sortable: true,
            resizable: true,
            filter: true,
        };
    }



    onGridReady(params) {
        this.gridApi = params.api;
        this.gridColumnApi = params.columnApi;

        this.http
            .get(
                'https://raw.githubusercontent.com/ag-grid/ag-grid/master/grid-packages/ag-grid-docs/src/olympicWinnersSmall.json'
            )
            .subscribe(data => {
                this.rowData = data;
            });
    }
}

and we’re done. Notice how flexible the headers are. You can expand them, drag and drop them.

I do not think there is any other library that provides these many exhaustive set of features.

As always, feel free to reach out if you need help with something. I’ll be honored to help.

It is like any other http file server but on steroids. Why?

Because it not only provides you the file sharing capabilities but also tags along other great features like download as zip and upload to the server.

Is it a complete thing?

No, not really. In fact, this is nowhere close to done. I will be adding a vast array of features down the line. Please stay tuned.

Why did I make this?

Duhhhh! Because I can.

Kidding aside. In my daily office works, I need to move files back and forth between multiple computers/laptops connected under a same network. So, this makes my (and my collegues) life much simpler and easier.

How to use it?

Ok, enough blabbering. Let’s get started. You will need Node installed on your laptop/computer and both the system you want to transfer files to and from should be under the same network. Basically, it needs to be connected to the same wifi network. In case, you have not installed Node, you can do so from this link.

Node will automatically install npm (Node Package Manager) for you from where you can install many other packages. It is like a market for node applications where you can pick stuffs and use it.

So,

1. Open a terminal/cmd/shell on your host machine (the machine from which you want to transfer the files to), and type:

    npm install -g see-my-files
   

   This will install the required things that you will need to run the application.

2. Then right after it you can simply do:

    see-my-files
   

   This will open up a server and give you a link.

The link that just got printed after running the above command can be used in any other computer to open a file system. The link should look something like: http://192.168.1.11:3300. Note this link and on the other computer simply open a browser and navigate to this very link.

You will see something link this:

To downlaod a file simply click on the file. It will automatically be downloaded. To download a folder you can right click on it and press download as zip. To upload something to the source machine you can simply drag the file to the folder icon. The upload will be done automatically.

Well. That’s it for this article. I really hope you find this useful.

As always, feel free to reach out to me if you need help.

Are you a developer as well?

Feel free to contribute: https://github.com/prameshbajra/see-my-files

Imagine the impression you will be making on a job application with the help of an unique email? You will be rocking your emails and people will notice it for sure.

Before we start. You might want to view this on your laptop because you cannot get this done from a mobile phone.

What will I guide you with?

From this:

To this:

There are some things you will need early hand. It might get a bit tedious but trust me, it’s worth it.

The steps are fairly simple and will require little to no skills.

Follow along

1. First thing first, head over to GMail.

2. You will have to enable a setting to proceed further. This can be enabled through couple of clicks.

3. Go to all setting and enable the options for templates (Follow the image below for better clarification). Click Save changes at the buttom of the page to save your changes.
   
   
   
   
   
   
   
   

4. Time to get a little technical now. Head to this URL and copy the entire HTML code.

5. Paste this into the editor you prefer (something like notepad) and make necessary edits.

   • Change https://prameshbajra.github.io to # if in case you do not have your own website. If you do, then replace this with your website link.

   • Replace all other social media links to your profile. Currently, the link refers to my profiles. Eg: Change https://www.facebook.com/prameshbajra/ to https://www.facebook.com/YOUR_USERNAME_HERE/.

   • After you’re done with all the edits select all and copy the entire HTML code. You will be needing this now.

6. After you’re done making the necessary changes, follow the below steps in the video. (Please do let me know if a youtube video would help. I would consider making one if need be.)
   
   
   
   
   

   In case you are wondering on what I just did there. Here are the steps to help process it.

   • I copied the HTML code that is to be sent in email. This is just the basic code to show the blue area and your name inside it.

   • Then I typed Anything in the message area and did a right click to open a menu on which I clicked Inspect Element.

   • After this I went ahead to the console area (the code part), selected the div element, right clicked and selected Edit As HTML.

   • I then removed the text (Anything) and replaced it with the HTML code that I have copied.

   • The content looks ugly at first but do not worry. We can go ahead and save it as a template. You need to provide a template name here. It can be anything you wish to name it.

   • The setup is done. Your template is now ready to be used.

   • Inorder to test it I clicked on Compose again and selected the saved template. The message area then changes automatically.

   • Now just type your email and send it.

7. Done. Congratulations! Now you have a professional email template.

Somethings I can help you out with:

• Feel free to contact me in any social media platforms (@prameshbajra) if you get stuck somewhere.

• If you are too lazy, not sure or too busy. Feel free to reach out to me. I can do this for you.

• If you want to see how the email looks. Drop a DM with your email ID. I will send you a sample email with this template.

• If in case you want some other design, something more pretty or more complex then contact me. I’d be happy to make one for you.

Hope this helps.

Let’s jump to the coding section.

We will be creating the application from scratch but, if in case, you need this in your existing application then feel free to jump ahead. I will be listing down the steps and you should be good to go just by simple copy and paste. But, before that there are some prerequisites in order to continue.

Prerequisites:

1. NodeJS installed.

2. Angular CLI installed.

Steps:

1. Create a new angular project. I will be using angular 8 here but this should work for any angular application above verison 2.

    ng new chartjs-demo
   

   If you are prompted with a configuration selection screen then you can select accordingly. However, I will be keeping everything as default.

2. Open the newly created project (chartsjs-demo in my case) in your favorite code editor.

3. For Angular2+ the equivalence library for ChartsJS is Ng2Charts and here we will be using the same. I will also be referring the Ng2Charts documentation for installing and setting up the charts.

4. Open a terminal in your current project folder and execute the following command.

    npm install --save ng2-charts
    npm install --save chart.js
   

5. The above step will install ChartJS library into your angular application. We need to import it as a module now. We do what we always do to import modules in angular. Import it in app.module.ts file.

    import { ChartsModule } from 'ng2-charts';
   
    // In your App's module:
    imports: [
      ChartsModule
    ]
   

   Just to be sure we are not bombarded with errors we can check our application in the browser by running ng serve -o.

6. A starter screen should automatically open and you should be able to see angular screen.

7. Now, moving on to the charts part. I will be creating the charts right at the App Component. So, to do this we can remove all existing code in app.component.html and add this snippet for rendering charts.

    <div>
        <div>
            <div class="chart">
            <canvas baseChart [data]="pieChartData" [labels]="pieChartLabels"
                [chartType]="pieChartType" [options]="pieChartOptions" [colors]="pieChartColors" [legend]="pieChartLegend">
            </canvas>
            </div>
        </div>
    </div>
   

   Similarly, in app.component.ts file you can replace the existing code with:

    import { Component } from '@angular/core';
    import { ChartType, ChartOptions } from 'chart.js';
    import { Label } from 'ng2-charts';
   
    @Component({
        selector: 'app-root',
        templateUrl: './app.component.html',
        styleUrls: ['./app.component.scss']
    })
    export class AppComponent {
        title = 'chartjs';
   
        public pieChartOptions: ChartOptions = {
            responsive: true,
            legend: {
                position: 'top',
            },
            plugins: {
                datalabels: {
                    formatter: (value, ctx) => {
                        const label = ctx.chart.data.labels[ctx.dataIndex];
                        return label;
                    },
                },
            }
        };
        public pieChartLabels: Label[] = [['PUBG'], ['Fortnite'], ['Call of Duty']];
        public pieChartData: number[] = [300, 500, 100];
        public pieChartType: ChartType = 'pie';
        public pieChartLegend = true;
        public pieChartColors = [
            {
                backgroundColor: ['rgba(255,0,0,0.3)', 'rgba(0,255,0,0.3)', 'rgba(0,0,255,0.3)'],
            },
        ];
   
    }
   

8. Switch back to your browser and you should see something like this.

   

9. Congratutions, we are done. The charts are at your disposal.
   
   

It was easy isn’t it? But it is very rare that your requirements will be this limited and abstract.

The chart we did here is just the tip of an iceberg. There are lots of other charts like line charts, bar charts, doughnut charts and scatter plots which you could make use of. All the available charts are present in this documentation. These charts are very customizable and configurable but unfortunately not all options are available in the documentation above. For more options regarding the configurations, you might want to have a look at CHARTJS Docs. Other entities might be different but the ChartOptions are exactly the same.

The entire code for this can be found here: https://github.com/prameshbajra/chartsjs-demo

Hope this helps! Happy Coding!

As always, feel free to get in touch if you need any help.

Here are 12 tips for you to write code that will help you and others as well.

1. Use linters.

Linters maintain code consistency. It helps in making code structure similar across all development teams such that there exist no confusion between developers. Linters also covers code indentation, use of proper variables, best modern practices etc. I, being a JavaScript developer use linters like ESLINT, JSLINT, JSHINT etc. Similar types of linters are available for python, java and pretty much all popular programming languages. These linters easily couples with you current code editors like VSCode, Atom, Sublime text and other full featured IDEs like Intellij , PHPStorm, WebStrom etc.

2. Favor high cohesion and low coupling.

Simply, cohesion just means a piece of code that does only one thing. This helps in reducing frequency of change in the software and it also gives low cyclomatic complexity which is very favorable. Changing or updating the code is also very easy if we do this. Coupling refers to a piece of code that depends or has some kind of relation with another part of code. We should keep our code as independent as it could be. Favoring low coupling is best for development and it also make testing very easy.

3. Schedule time to lower technical debt.

This is a non-technical criteria to keep in mind when writing code. Writing poor quality code is not technical debt. If you are working on a solo project or a project that doesn’t have a deadline then you may skip this point but, if you are working for someone or some company then schedule your time and work on your part. Schedule time to plan, write code, test and reviews accordingly. If you do not do this then your project will definitely lack in some part.

4. Program with intention.

Always have a goal on what you are trying to accomplish by writing a program. Never follow “Heat and trial” approach. One of the best way to program with intention is to write tests first and then write program that makes the test pass. This will be difficult at first but trust me, it’s worth it. What this approach does is that it forces you to move towards your goal. It will be like moving to a certain fixed destination that you are aware of.

5. Avoid primitive obsession.

“It is better to reuse than to rewrite” – always keep this in mind. Try not to rewrite the functions, classes or any snippets that is already available in the codebase. Those methods are highly efficient and also written by one of the best developers. If you think that your method can surpass those predefined methods then a rewrite would be considerable, but remember this is very unlikely.

For example -

to sort an array in java you do not have to write a sorting algorithms everytime, you can just use Arrays.sort(ArrayName).

This is concise, self explanatory, short and efficient. We should avoid writing code at lowest level possible. Also, prefer to code in functional style rather than imperative style.

Note: Functional Programming > Imperative Programming.

6. Always prefer clean code, not clever code.

Writing clever code makes you feel good, and you are not alone. It gives you a moment of joy and confidence. There is a quote that goes by – “Programs must be written for people to read and only incidentally for machine to execute”. I want you to remember this quote next time you write any clever code. I want to focus on one main drawback by writing clever code. Well it’s clear that you won’t remember every line of code that you wrote. May be after couple of months you won’t even remember working on the project. So, by case if you have to change a piece of code or you perhaps want to add a feature then you have to go back and read the same clever code that you wrote months back. This code will definitely confuse you and take up a good portion of your time. To avoid these kind of scenarios we should avoid writing clever code.

7. Apply Zinsser’s principle.

“Hard writing makes easy reading and easy writing makes hard reading” – Zinsser’s Principle. So to make this clear, take your time to code. Think about the clean and easy way to code such that it will be easier for others and future you to read it without getting stuck and wasting too much time. I also would like to suggest everyone to leave a blank line after each function declaration, class definition or any transition relevance act. This makes reading code very easy and transitions and breaks are understood by everyone.

8. Comment why, not what.

A good code is like a good joke, it’s not worth it if you have to explain it. Always only comment the logic behind the code. Try to write expressive self-documenting code. Comment why the code is there not what that code does.

For example:

i++; // post increment i value by one

these types of comments are stupid so please avoid these. Rather explain why is the increment done.

9. Avoid long methods.

When writing methods apply SLAP (Single level of abstraction principle). You might have a slight guess why developers do not prefer long methods. I personally do not like long methods because they are hard to maintain, hard to debug, difficult to test and even harder to refactor. Long methods have high coupling and low cohesion, they are not suitable to reuse and long methods leads to duplication of code. They violate good coding principles. So, separate a method when you think it’s level of abstraction is complete.

10. Follow naming conventions.

This is a must follow rule for everyone (Especially in our college). Always name your methods, classes and variables meaningfully. Avoid naming variables as single letters.

For example –

int a , b, c;

Never do this. These variables do not explain what they do. They enhance the complexity of the program and creates more confusion. For classes, remember to name their initials in capital letters. For method and variable you can either follow snake_casing or CamelCasing.

11. Use tactical code reviews.

Code review is generally done in groups, like in a meeting. I call this a bad idea. Not everybody has similar views on the code you write. Some might like your code and some won’t. Reviewing this in groups will create diverse results making it harder to decide. What can be a better alternative is to invite a colleague or another developers from the same company and cross review the code. I mean you reviewing your colleague code and your colleague reviewing your code. This will save time and resource, as well as maintain a friendly environment.

12. Reduce state and state mutations.

Simple trick is to start writing functions before declaring variables. They somehow force you to know the nature of the variables and use them properly. Messing with the state is the root of man problems both in software and in politics.

1. Speech recognition

2. Learning

3. Planning

4. Problem solving

Artificial intelligence is a branch of computer science that aims to create intelligent machines. It has become an essential part of the technology industry.

Research associated with artificial intelligence is highly technical and specialized. The core problems of artificial intelligence include programming computers for certain traits such as:

1. Knowledge

2. Reasoning

3. Problem solving

4. Perception

5. Learning

6. Planning

7. Ability to manipulate and move objects

Knowledge engineering is a core part of AI research. Machines can often act and react like humans only if they have abundant information relating to the world. Artificial intelligence must have access to objects, categories, properties and relations between all of them to implement knowledge engineering. Initiating common sense, reasoning and problem-solving power in machines is a difficult and tedious approach.

Machine learning is another core part of AI. Learning without any kind of supervision requires an ability to identify patterns in streams of inputs, whereas learning with adequate supervision involves classification and numerical regressions. Classification determines the category an object belongs to and regression deals with obtaining a set of numerical input or output examples, thereby discovering functions enabling the generation of suitable outputs from respective inputs. Mathematical analysis of machine learning algorithms and their performance is a well-defined branch of theoretical computer science often referred to as computational learning theory.

Machine perception deals with the capability to use sensory inputs to deduce the different aspects of the world, while computer vision is the power to analyze visual inputs with a few sub-problems such as facial, object and gesture recognition.

Robotics is also a major field related to AI. Robots require intelligence to handle tasks such as object manipulation and navigation, along with sub-problems of localization, motion planning and mapping.

A.I. And Quantum Computing

The truth is that, whether or not true A.I. is out there or is actually a threat to our existence, there’s no stopping its evolution and its rise. Humans have always fixated themselves on improving life across every spectrum, and the use of technology has become the vehicle for doing just that. And although the past 100 years have seen the most dramatic technological upheavals to life than in all of human history, the next 100 years is set to pave the way for a multi-generational leap forward.

This will be at the hands of artificial intelligence. A.I. will also become smarter, faster, more fluid and human-like thanks to the inevitable rise of quantum computing. Quantum computers will not only solve all of life’s most complex problems and mysteries regarding the environment, aging, disease, war, poverty, famine, the origins of the universe and deep-space exploration, just to name a few, it’ll soon power all of our A.I. systems, acting as the brains of these super-human machines.

However, quantum computers hold their own inherent risks. What happens after the first quantum computer goes online, making the rest of the world’s computing obsolete? How will existing architecture be protected from the threat that these quantum computers pose? Considering that the world lacks any formidable quantum resistant cryptography (QRC), how will a country like the United States or Russia protect its assets from rogue nations or bad actors that are hellbent on using quantum computers to hack the world’s most secretive and lucrative information?

Applications of Artificial Intelligence In Use Today

Beyond our quantum-computing conundrum, today’s so-called A.I. systems are merely advanced machine learning software with extensive behavioral algorithms that adapt themselves to our likes and dislikes. While extremely useful, these machines aren’t getting smarter in the existential sense, but they are improving their skill and usefulness based on a large dataset. These are some of the most popular examples of artificial intelligence that’s being used today.

1. Siri

Everyone is familiar with Apple’s personal assistant, Siri. She’s the friendly voice-activated computer that we interact with on a daily basis. She helps us find information, gives us directions, add events to our calendars, helps us send messages and so on. Siri is a pseudo-intelligent digital personal assistant. She uses machine-learning technology to get smarter and better able to predict and understand our natural-language questions and requests.

2. Alexa

Alexa’s rise to become the smart home’s hub, has been somewhat meteoric. When Amazon first introduced Alexa, it took much of the world by storm. However, it’s usefulness and its uncanny ability to decipher speech from anywhere in the room has made it a revolutionary product that can help us scour the web for information, shop, schedule appointments, set alarms and a million other things, but also help power our smart homes and be a conduit for those that might have limited mobility.

3. Tesla

If you don’t own a Tesla, you have no idea what you’re missing. This is quite possibly one of the best cars ever made. Not only for the fact that it’s received so many accolades, but because of its predictive capabilities, self-driving features and sheer technological “coolness.” Anyone that’s into technology and cars needs to own a Tesla, and these vehicles are only getting smarter and smarter thanks to their over-the-air updates.

4. Cogito

Originally co-founded by CEO, Joshua Feast and, Dr. Sandy Pentland, Cogito is quite possibly one of the most powerful examples of behavioral adaptation to improve the emotional intelligence of customer support representatives that exists on the market today. The company is a fusion of machine learning and behavioral science to improve the customer interaction for phone professionals. This applies to millions upon millions of voice calls that are occurring on a daily basis.

5. Boxever

Boxever, co-founded by CEO, Dave O’Flanagan, is a company that leans heavily on machine learning to improve the customer’s experience in the travel industry and deliver ‘micro-moments,’ or experiences that delight the customers along the way. It’s through machine learning and the usage of A.I. that the company has dominated the playing field, helping its customers to find new ways to engage their clients in their travel journeys.

6. John Paul

John Paul, a highly-esteemed luxury travel concierge company helmed by its astute founder, David Amsellem, is another powerful example of potent A.I. in the predictive algorithms for existing-client interactions, able to understand and know their desires and needs on an acute level. The company powers the concierge services for millions of customers through the world’s largest companies such as VISA, Orange and Air France, and was recently acquired by Accor Hotels.

7. Amazon.com

Amazon’s transactional A.I. is something that’s been in existence for quite some time, allowing it to make astronomical amounts of money online. With its algorithms refined more and more with each passing year, the company has gotten acutely smart at predicting just what we’re interested in purchasing based on our online behavior. While Amazon plans to ship products to us before we even know we need them, it hasn’t quite gotten there yet. But it’s most certainly on its horizons.

8. Netflix

Netflix provides highly accurate predictive technology based on customer’s reactions to films. It analyzes billions of records to suggest films that you might like based on your previous reactions and choices of films. This tech is getting smarter and smarter by the year as the dataset grows. However, the tech’s only drawback is that most small-labeled movies go unnoticed while big-named movies grow and balloon on the platform.

9. Pandora

Pandora’s A.I. is quite possibly one of the most revolutionary techs that exists out there today. They call it their musical DNA. Based on 400 musical characteristics, each song is first manually analyzed by a team of professional musicians based on this criteria, and the system has an incredible track record for recommending songs that would otherwise go unnoticed but that people inherently love.

10. Nest

Most everyone is familiar with Nest, the learning thermostat that was acquired by Google in January of 2014 for $3.2 billion. The Nest learning thermostat, which, by the way, can now be voice-controlled by Alexa, uses behavioral algorithms to predictively learn from your heating and cooling needs, thus anticipating and adjusting the temperature in your home or office based on your own personal needs, and also now includes a suite of other products such as the Nest cameras.

PS : The shout out for this article post goes to a sophomore computer science engineer “Shovit Raj Paudel”.
Be sure to follow him on instagram : shovitrajpaudel

So, What is Bitcoin?

“Bitcoin is considered to be the beginning of something great: a currency without a government, something necessary and imperative.”

Bitcoin is a crypto money/ currency and worldwide payment system. It is the first decentralized digital currency as the system works without a central bank. The difference between real money and the bitcoin is that Bitcoin is just a bit of data whereas the money we use is a piece of paper. They are stored in digital wallets.

How to get bitcoin and how the bitcoin network works?

For getting bitcoin you must mine, it’s like searching for gold, but, in digital way because it’s not a physical money, it’s a digital currency. Mining is important and integral part of bitcoin that ensures fairness while keeping the bitcoin network safe, stable and secure. Actually, in case of bitcoin: mining means solving the mathematical problems.

Someone is mining bitcoin, means that he/she is solving mathematical problems using a machine. When the mathematical problem is solved the miner is rewarded by bitcoin. When you send and receive bitcoin, your transactions are recorded in a ‘Block Chain’.

Block Chain is network where you are known by a cryptographic hash (Alphanumeric string), which means that you do not have to show your identity in order to do something with bitcoin.

As the process looks simple, it’s way harder to get it because it’s getting rarer. The more the bitcoin is found, number of bitcoin users are increased and the problems to be solved will get harder and harder. It requires very powerful computer to mine a single bitcoin. Though it needs powerful system, bitcoin was mined first time by using 55 years old IBM pc.

Then people started using the latest CPU’s. Later they started using GPU’s which were made for gaming.

Now In 2018, People use special computer which uses ASIC (Application Specific Integrated Circuit) chips in order to mine bitcoin for getting more profit. Since mining uses more power, it will reduce the life of the chips if you are using low end chips. The more powerful the cards, more will be the profit.

You might think of mining bitcoins in your laptop, please forget it. I tried it once the results were not at all worth it and all you will do is wear out your CPU/ GPU.

Nowadays, people also practice pool mining. In pool mining, a group of people work together for solving the mathematical problem and when it is solved the members are rewarded with proportionate amount of bitcoin according to their work.

Where can you use bitcoin?

Since bitcoin is a cypto currency, you can exchange it for real money. It’s way more expensive than real money. According to 2017 data one bitcoin equals to 9385.92 US$ and rapidly increasing. It’s price keeps on changing.

Bitcoin doesn’t reveal the identity of the user, so many people use this currency for buying and selling illegal things like drugs, military grade items and confidential information. This is also one of the main reason that Bitcoin is banned is many contries like Nepal, SriLanka etc.

Future of bitcoin: It is stated that there are around 21 million bitcoins in the world, out of which 12 million have already been mined. I think it’s value will increase more and more due to it’s privacy and craze of people on bitcoins. Everybody wants to have their hands-on bitcoin.

You might also be the one to get it. If so, you might also be one of the lucky one.

As, writing of the post the value of bitcoin is 8400$ + which fell down from 19000$.

PS : Unlike other posts, I didn’t write this one. The complete credit goes to a Computer Engineer and a very enthusiastic programmer - “Subodh Ghimire”.
Be sure to follow him on instagram : subodhghimire99

Let’s start by changing the format of your current CMD. Follow along and please do ask if you get stuck somewhere.

1. Open your CMD / Command Prompt , copy this > setx prompt $$ $C$P $L--$G $D$F$_$C$$$F -$G and paste it. Then press enter. (You might have to restart your CMD / Command Prompt)

2. Your CMD should now look something like

   $ (C:\Windows\Temp <--> 2017-08-03)

   ($) -> █

   
   If you do not like this format then you can customize it yourself. Enter prompt /? and see the formatting options. For your convienence they are mention below:
   Start with setx prompt then make your own format as above.
   

    - $A       &           (Ampersand) 
    - $B       |           (pipe) 
    - $C       (           (Left parenthesis) 
    - $D                    Current date 
    - $E                    Escape code  (ASCII code 27) 
    - $F       )           (Right parenthesis) 
    - $G       >           (greater-than sign) 
    - $H       Backspace   (erases previous character) 
    - $L       <           (less-than sign) 
    - $M       Display the remote name for Network drives
    - $N       Current drive 
    - $P       Current drive and path 
    - $Q       =           (equal sign) 
    - $S                    (space) 
    - $T       Current time 
    - $V       Windows NT version number 
    - $_       Carriage return and linefeed 
    - $$       $           (dollar sign)
    - $+       Will display plus signs (+) one for each level of the PUSHD directory stack
    

3. I’m guessing you haven’t changed the font and color yet. In case you have or you like the default one skip this step. Right click on the title bar and go to properties , select Font tab and choose any font of your liking. Then go to Colors and choose your preferable color for screen text and screen background. After you’re done press OK.
   

Very simple, Isn’t it?
Now let’s add a feature that preserves history between sessions and tab on completion. This is very simple just download Clink and install it.

Annnnnd!! You’re done. Congratulations!

Let’s get started:

Prerequisites

Before reading this the reader is expected to have a general idea for generating model from tensorflow. You will need to that this part comes only after your model is successfully trained and the models are generated.

In order to deploy your models to Sagemaker you need to make sure of some things before you start. Firstly, make sure that the folder structure is something like this:

some_name 
    |__ Some positive number that represents version (For eg: 1) 
            |__ saved_model.pb 
            |__ variables 
                    |__ (Non empty)

Keep in mind that the variables folder should not be empty. The variables folder in most of the case are empty because the original tensorflow object detection tutorial exports a frozen graph instead of unfrozen one. Here, frozen means that all the variables are frozen (i.e. made constants). Because of this reason the variables folder is empty. We will have to export an unfrozen graph. Follow my another blog in order to export an unfrozen graph.

After you have the above folder structure you can compress it into a some_name.tar.gz format. Notice that we have a positive numbered folder inside model directory. Your model folder can have multiple positive numbered folders. These will be treated as versions and Sagemaker will choose the highest version (i.e. highest positive number inside model directory) to deploy.

Setup model for Sagemaker

After the prerequisites are done, you can proceed by uploading your some_name.tar.gz into S3. You can do it manually too. Just in case you want to upload it by using code here is the way to do it.

from sagemaker.session import Session

model_data = Session().upload_data(path='<PATH TO some_name.tar.gz>', key_prefix='model')
print(model_data)

This will print the S3 path to some_name.tar.gz. Make sure to copy it.

Initialize the model

Sagemaker SDK is very powerful and amazing. You can use one line code to create a model, it’s respective endpoint configuration and endpoint. The model can be initialized by using the code below:

from sagemaker.tensorflow.serving import Model

# Use an env argument to set the name of the default model.
# This is optional, but recommended when you deploy multiple models
# so that requests that don't include a model name are sent to a
# predictable model.
env = {'SAGEMAKER_TFS_DEFAULT_MODEL_NAME': 'some_name'}
# set specific role
sagemaker_role = "YOUR ROLE NAME FOR SAGEMAKER"

model = Model(
    model_data=
    '<Paste the S3 path to some_name.tar.gz>',
    role=sagemaker_role,
    framework_version="1.14",
    env=env)

Another thing to keep in mind here. The framework_version that you provide when initializing the model above must be same as the version of tensorflow that was used to train the model. So, make sure to do some saerching on the trained version before using any random version for deployment.

Deploy the model

Use the code below to deploy the model. Sagemaker will do the heavy lifting for you from here on and create an endpoint that will be ready to take in inputs and return your predictions. The model.deploy() method will return a predict object that can take in inputs and give out predictions.

# This will take some time ... Grab a coffee, take a break ...
predictor = model.deploy(initial_instance_count=1,
                         instance_type='ml.t2.medium')

Based on you requirements you can increase the initial_instance_count and change the instance_type to a more powerful instance. You can even set a accelarator_type too by simply adding a parameter to model.deploy() function. Eg: predictor = model.deploy(initial_instance_count=1, instance_type='ml.c5.xlarge', accelerator_type='ml.eia1.medium')

Get predict from endpoint

From the predictor object you can get the endpoint_name that the model has been deployed to. This method is necessary because every time you will call predict() it is not feasible to deploy the model. What you can do is get the predictor object from the endpoint. You can do this by :

from sagemaker.tensorflow.serving import Predictor

predictor = Predictor(endpoint_name = "<Your endpoint name>")

There are other ways to do this too. You can use RealtimePredictor that sagemaker provides. I won’t be including that here as that would make this a long post.

Testing is must

We are on the final stage now. We need to get the prediction done. But wait, sagemaker endpoint only accepts json/csv format (Not sure why). We have to pass image to this. We can do this by :

import cv2
import numpy as np

headers = {"content-type": "application/json"}
image_content = cv2.imread("<Path to your image>",
                           1).astype('uint8').tolist()
body = {"instances": [{"inputs": image_content}]}

results = predictor.predict(body)

print(results)

This will get you some output in dict format having elements like detection_classes, detection_boxes etc. This output that you get here is similar to the one you get when you run object detection in tensorflow. You will have to arrange or even write up some code in order to get the co-ordinates for detections done.

Feel free to ping me anywhere in social media if you get stuck somewhere or in case you have some questions.

First of all, I am not sure why you would want to do this. For me this was just a play- around thing. Turns out, this is easy AF.

First, setup you express project. I did this like:

express --ejs myApplication

If you are not sure what this is then please check out express-generator, you can install it by:

npm i -g express-generator

Here’s a reference for convienence. Express generator

Just to make things clear beforehand we won’t be changing anything in the application itself. Most of the changes will be in the package.json file.

Your package.json file would look something like this at first:

{
    "name": "package-name",
    "version": "0.0.1",
    "private": true,
    "scripts": {
        "start": "node ./bin/www"
    },
    "dependencies": {
        "Your dependancies here"
    }
}

You should add some elements here such that your final package.json would look something like this:

{
    "name": "package-name",
    "version": "0.0.1",
    "private": false,
    "main": "./bin/www",
    "scripts": {
        "start": "node ./bin/www"
    },
    "bin": {
        "package-name": "./bin/www"
    },
    "dependencies": {
        "Your dependancies here"
    }
}

Watch out for the "private": false part if you are going to release you npm package as public.

We are pretty much done at this point.

Before publishing make sure that you have your account set up at : NPM JS and login from terminal.

You can login to npm from your command line using :

npm login

After this you can simply:

npm publish

If everything is good and god is on your side then you should be able to publish your package successfully. Give it a try and let me know which app you published. I’d be happy to use it.

If there is any doubt along the way, please feel free to drop a mail or contact me through any means.

Because the offical tutorial for tensorflow object detection only exports a frozen graph. These frozen graphs are all good for testing the model and some small prediction works but for production they are a huge pain to work with. Again, the documentation is not clear on what needs to be done in order to make this model production ready.

Here are something we need to know before continuing:

• We should have a surfacial understanding on object detection using tensorflow as this part comes only after our training is done and the checkpoint files are generated. More on this later.

• We need to know that tensorflow has a tensorflow serving that allows one to production ready models. But these servings only take in unfrozen graph and in the documentaion (when this blog was written) it is not mentioned how to export a unfrozen graph. This is the main reason this blog exists.

• Exporting checkpoints to a graph are no where to be found and many ways do not work.

Diving into Tensorflow directories:

Just a second, before diving into tensorflow directories in order to export an unfrozen graph we will need to have checkpoint files that gets generated from the output from training the model. These checkpoint files look something like:

output_path
    |__ model.ckpt-<checkpoint>.data-00000-of-00001
    |__ model.ckpt-<checkpoint>.index
    |__ model.ckpt-<checkpoint>.meta

The checkpoint will be a number that means how much steps it has been trained on. We can have many files like this. Just make sure to remember the highest number among all.

With that out of the way we can start changing the code for exporting the unforzen graph.

Start by changing exporter.py file located in models/research/object_detection/exporter.py. Replace the function write_saved_model() with this:

def write_saved_model(saved_model_path, trained_checkpoint_prefix, inputs,
                      outputs):
    """Writes SavedModel to disk.
  Args:
    saved_model_path: Path to write SavedModel.
    trained_checkpoint_prefix: path to trained_checkpoint_prefix.
    inputs: The input image tensor to use for detection.
    outputs: A tensor dictionary containing the outputs of a DetectionModel.
  """
    saver = tf.train.Saver()
    with session.Session() as sess:
        saver.restore(sess, trained_checkpoint_prefix)
        builder = tf.saved_model.builder.SavedModelBuilder(saved_model_path)

        tensor_info_inputs = {
            'inputs': tf.saved_model.utils.build_tensor_info(inputs)
        }
        tensor_info_outputs = {}
        for k, v in outputs.items():
            tensor_info_outputs[k] = tf.saved_model.utils.build_tensor_info(v)

        detection_signature = (
            tf.saved_model.signature_def_utils.build_signature_def(
                inputs=tensor_info_inputs,
                outputs=tensor_info_outputs,
                method_name=signature_constants.PREDICT_METHOD_NAME))

        builder.add_meta_graph_and_variables(
            sess,
            [tf.saved_model.tag_constants.SERVING],
            signature_def_map={
                signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:
                detection_signature,
            },
        )
        builder.save()

Notice that there are some changes, the frozen_graph_def has been changed with trained_checkpoint_prefix.

After this we also need to change the caller of this function:

Replace

write_saved_model(saved_model_path, frozen_graph_def, placeholder_tensor, outputs)

with

write_saved_model(saved_model_path, trained_checkpoint_prefix, placeholder_tensor, outputs)

Done

It was simple, wasn’t it? I still am not sure why tensorflow still doesn’t provide this code or include this in their official github documentation. This could help a lot of people. Anyways, we are done here. All we have to do is run the same command we run when we need to export a graph.

The command would be something like :

# From directory tensorflow/models/research/

INPUT_TYPE=image_tensor
PIPELINE_CONFIG_PATH={path to pipeline config file}
TRAINED_CKPT_PREFIX={path to model.ckpt}
EXPORT_DIR={path to folder that will be used for export}
python object_detection/export_inference_graph.py \
    --input_type=${INPUT_TYPE} \
    --pipeline_config_path=${PIPELINE_CONFIG_PATH} \
    --trained_checkpoint_prefix=${TRAINED_CKPT_PREFIX} \
    --output_directory=${EXPORT_DIR}

It’s obvious we have to provide our own path to the necessary files like configs and directories. Also, this might be a bit confusing but the TRAINED_CKPT_PREFIX is the number that I asked you to remember in the beginning of the blog.

Verify

You can verify that the unfrozen graph has been exported by checking files under saved_model/variables directory. There should be files like :

saved_model
    |__ saved_model.pb
    |__ variables
            |__ variables.data-00000-of-00001
            |__ variables.index

Congratulations on getting the graph, but we did this for a reason. Making this model production ready.

I have another blog that deploys the model to sagemaker to makes predictions. Make sure to go through this.

Let me know if you get stuck somewhere or you have any confusion. Drop me a mail or message me at twitter - @prameshbajra. I will help as much as I can. Thank you.

GitHub and similar services bring all of the benefits of a decentralized VCS to a centralized service. GitHub also stores a copy of your project’s repository just like any other developer. Then, you basically designate that as the project’s central repository and all the developers push and pull their changes to and from that repository. GitHub takes this a step further by encouraging developers to fork a project’s repository and then use that as their own centralized repository. From there they can send “pull requests” to the main project with their changes and then the project maintainers can review them before deciding whether to include them in their project or not.

So what are the three best reasons to use GitHub?

1. It makes it easy to contribute to your favorite open source projects.
   Today, nearly every open-source project uses GitHub to manage their project. GitHub is free if your project is open source and includes a wiki and issue tracker that make it easy to include more in-depth documentation and get feedback about your project. Symfony, Ruby on Rails, and Django all use GitHub (symfony, rails, django) to develop their project and accept contributions from the community. Even the GitLab source is available at GitHub! If you want to contribute, you just fork their project, make your changes and then send them a pull request using the GitHub web interface.

2. GitHub has some of the best documentation around.
   You won’t run out of content when you use GitHub, thanks to a well-padded guide and help section for articles that you can pull up for practically any topic on earth, for as long as it is related to a git. It’s got content for helping you learn about generating SSH keys. A guide for the best git workflow is available. Samples on gitignore (and more) are abound for your next planned project, among other things. You would not need to look elsewhere for all the information that you need.

3. GitHub has Gists and GitHub Pages, too.
   A while back, GitHub rolled out a feature called Gists, which lets you convert one or several files into a working git repository. This new feature converted sharing and tracking changes made to configuration files and even simple scripts into a whole new level of easy. While they aren’t as rich in features like a full-blown GitHub repository, they really work well even if you are without a paid account. GitHub pages, on the other hand, lets you host static websites by simple assigning HTML pages onto another, separate repository – the way you would any other type of git repository. With this, blogging can be done off the bat as well as updating with additional documentation or bumping up its web presence.

4. Become a better developer.
   Probably the most beneficial part is, it help you to become a better developer. You can go through different people code as well as create something new and show it to people around you. A great way to showcase your work and attract recruiters and bigger companies. Nowadays a lot of companies look into your github profile too and if you are not from some great university or college building a good github profile certainly going to help you.

I hope I have made some valid points regarding GitHub. If not, there is always more.

• Version control your projects.

• Push your projects to GitHub and let the world know how nice and useful code you write.

• Explore other’s projects on GitHub, get inspired code more, or contribute to their project.

• Collaborate with others, by letting other people contribute to your projects or you contributing to other’s projects.

• Maintain useful lists. I didn’t find anything better then creating lists on GitHub using markdown. I like how clean it looks.

• Learn Git.

• Link your nice GitHub profile while applying for grants, jobs, in your resume. It makes things better and helps.

These reason suffice to make any developer use GitHub. So get started on it.

Also find me on github : Suzal3579

2012, After school. The final exams were over and my school life eventually came to an end. I was quite confident that I would get good grades. My family had huge expectation from me. They promised me to get a new phone if I get 80+. Good thing, I did. This accompolishment got everyone happy, that my family brought me a new phone. Back then android was unheard of and touchscreen was just a new kid in the block. I still remember the shop (Merina Mobiles, New Road) where we went to buy my new phone. I chose Samsung Galaxy Young. That puny phone cost 12000rs, back then. I can’t imagine now how happy I was. This single purchase was my entry ticket to the world of technology.

After School - Starting line to the Journey

It was this time I got a great friend (Prasanna Mishra). We were in same school, but interacted once in a bluemoon. The bridge course classes we attended made us great buddies. This guy was curious AF. My new phone got both of us excited but it was Prasanna who tried out new stuffs like keeping launchers, making, breaking and hacking through several apps. This thing intrigued me. I wanted to play around too. Then after couple of months he got his first smartphone too. It was a cute HTC. We used to be in his place all the time as my place had no internet nor a laptop. Those time gave us great understanding about the android world.

College Time - All About Smartphone

College was all about custom roms, cool applications and android launchers. We were flashing android firmwares and custom softwares like pros. Ok! I’ll be honest, It was Prasanna most of the time but yea, it was his home, his internet and his laptop after all. We were too much into smartphones that we got known for it. Our friends, relatives used to call us to fix their phones. We used to be updated with latest phone releases, android versions and so called specs chart. I believe it was around this time I was first introduced to code. I thought code was only written by highly intelligent individuals and is not for a no brainer like me. Top of that I did not have a laptop too. So, I never bothered.

After College - Where it all changed

So, what after college? Engineering? Perhaps, Civil? Everybody had plans for me to join civil engineering. (Echoing voices… Civil Engineers are paid high and has great scope) But, as you might have guessed, technology is what I was interested in and wanted to work on for all my life. I had “the career talk” with everybody. The one and the only talk that went in my head and stayed are my mom’s words “Are you even interested in civil? I do not think so. Everyone says you are good with smartphones. We are not educated like others and we don’t know what happens in either of the fields. So, this decision is completely up to you. I think you should choose what you feel like studying. Money can be earned from either of them right ?”. These were the exact words (Just translated in english) that came from her. I was baffled. These words from her, totally changed my life. I can’t express how thankful I am to you MOM <3. This decision of joining Computer Science Engineering was one of the best decision of my life.

But remember? I still did not have a laptop. My mom and my elder mom were saving money for me to get a laptop as I was insisting on it for long. They saved nearly 30000rs but that was no where close to get a decent one. We were planning to get a second hand. Then, a miracle happened. One day me and my mom were out for some grocery shopping my mom stepped into something. She looked down, bowed and picked up a shiny thing. That shiny thing was a gold ring. There was no one around to ask if it was theres. We stood there for a while but no one came by. So… we kept it, like every good citizen does :P . After we got home my mom held me and told - “Now you don’t have to wait long for a new laptop”. We then went to a relatives jwellery store and asked him how much would we get for the ring? He examined and replied - “I can give you 23000 for this ring”. I literally felt like crying that moment. A laptop I was aiming to get was around 55000rs and the ring that came for 23000rs and 30000rs from savings just made my wish possible. We sold the ring and went to get a new laptop after couple of days. Matter of fact, this blog is writen using the very laptop I am talking about. Yeah, I’m stil using it to this day.

Best thing comes with the worst ones, right? Yeah, that’s what happened next. I was not selected in one of the finest colleges in Nepal, obviously!!. I then got a chance to study in India. Now this, was one of the worst decision of my life. I regret it till date.

India - Computer Science Engineering

I joined BVC Engineering College in Andra Pradesh, India. First year was a nightmare. No internet, No clean gym, No good food, No clean water and basically everything was crap. It was extermly difficult to learn something new. So, all I can do was play basketball and read text books. My family, as usual, had expectations from me to do well. Amazingly, I nearly topped the first year. My family members were happy, but they had no idea that I didn’t like it there at all. Moving on to the second year, the internet improved a bit and I started downloading youtube tutorial videos, smartphone reviews and some informative tech videos to learn in free time. I used to set an alarm at 1 am, 3 am and 5am just to check if I could queue up some other downloads or whether the internet is still working or not. 3 fourth of my hard drive was filled with youtube videos and more than half of it was tutorials. Like this, I starting watching coding videos. They made no sense at all at first.

I was about to quit but the feeling when you get when your code works is heavenly. Overcoming the difficulties and being able to code a simple app gave me drops of happiness. It was like a self-pat at the back. Say “Well done! You’re the best :D.” to yourself. Honestly, I did not love to code when I started. I was just learning to code as a time pass thing. But, you know as Carl Jung said - “You are what you repeatedly do”. I started getting kinda good in coding. Technical things and some cryptic words that was in my course pulled me into it. I started learning more and more and never stopped working on my learning. I topped my batch in my second year (NERD ALERT!!!!). Then the internet became more stable and a bit faster than before. The food became a habit. By this time I always had my hands full. Attending college, playing basketball, learning new stuffs and coding were my daily jam. I barely had time to talk to my friends at home.

Looking back, I am glad I never stopped learning and was off the radar for quite a long to learn and improve. If only I had quit or did not show any interest to learn I would be regretting it a lot today. My friends still say this to me - “You put in your work and got what you deserve”. Missing parties, staying hungry, saying no to long tours, I don’t regret it all. It was all for a reason - A reason to do something for my family and learn to the fullest.

I hope when I read this after a couple of years, it will bring back some memories and a wide smile :)

Jupyter Notebooks has support for over 40 programming languages, including Python, R, Julia, and Scala.

If you are like me then you are never satisfied with out of the box experience on any development environment. I literally spend hours tweaking tools, changing fonts, colors and what not. Making the tools/ides look better than the code to be honest. I am writing this guide for Ubuntu/Linux users but this should pretty much help for all platforms. You just have to search for the respective folders. So, let’s begin.

We will start by tweaking the default theme that’s provided by jupyter.

• For this you will need to find .jupyter folder - Usually located in home/.jupyter. Try ctrl + h if your files are hidden.

• Then, you need to navigate inside the folder and go inside custom folder. Now, all you need to do is change custom.css file.

• If you do not like the width of your notebook then you can change it by adding the snippet below in custom.css file. Do not change anything else (I am not responsible for the things you break, or just take a back up of your custom.css before moving further.).

    .container { 
        width:90% !important; 
    }
  

• You can also change the fonts. Just replace the font name in the same file and most of all remember to place the font under fonts folder the you will find right beside custom.css

• Also, I have no idea what custom.js does.

If you are curious on what styles am I using then here is the full custom.css of mine:

@font-face {
    font-family: "Hasklig";
    font-weight: normal;
    font-style: italic;
    src: local('"Hasklig"'), url('fonts/hasklig.otf') format('opentype');
}
@font-face {
font-family: "Hasklig";
font-weight: normal;
font-style: italic;
src: local('"Hasklig"'), url('fonts/hasklig-italic.otf') format('opentype');
}

.container { 
    width:90% !important; 
}

div#notebook {
    font-size: 11px;
}

div.prompt {
    min-width: 10ex;
}

.timing_area {
    font-size: 60% !important;
}

.CodeMirror {
    line-height: 1.50em;
    font-size: 12px;
    height: auto;
    background: none;
}

.completions select {
    background: white;
    outline: none;
    border: none;
    padding: 0px;
    margin: 0px;
    overflow: auto;
    font-family: monospace;
    font-size: 90%;
    color: #000;
    width: auto;
}

<script>
    MathJax.Hub.Config({
        "HTML-CSS": {
            /*preferredFont: "TeX",*/
            /*availableFonts: ["TeX", "STIX"],*/
            styles: {
                scale: 80,
                ".MathJax_Display": {
                    "font-size": "80%",
                }
            }
        }
    });
</script>

By, this time you might wonder on how I got the css selectors name (Eg: css class names). For this you need to start Jupyter Notebook and open any .ipynb files that you have. .ipynb files are basically the iPython files (Interative Python). You can then inspect element on the page and select the class name of the element that you would like to change. (ctrl+shift+c In case you prefer shortcuts)

Update 2020: By this time there is this advent of dark-mode everywhere, here is my CSS for dark mode. Only CSS is to be changed. Replace your custom CSS with this:

div#notebook {
    font-family: sans-serif;
    font-size: 9pt;
    line-height: 170%;
    color: #f8f8f0;
    -webkit-font-smoothing: antialiased !important;
    padding-top: 25px !important;
}

body,
div.body {
    font-family: sans-serif;
    font-size: 9pt;
    color: #f8f8f0;
    background-color: #1e1e1e;
    background: #1e1e1e;
    -webkit-font-smoothing: antialiased !important;
}

body.notebook_app {
    padding: 0;
    background-color: #1e1e1e;
    background: #1e1e1e;
    padding-right: 0px !important;
    overflow-y: hidden;
}

a {
    font-family: sans-serif;
    color: #f8f8f0;
    -webkit-font-smoothing: antialiased !important;
}

a:hover,
a:focus {
    color: #f8f8f0;
    -webkit-font-smoothing: antialiased !important;
}

div#maintoolbar {
    position: absolute;
    width: 90%;
    margin-left: -10%;
    padding-right: 8%;
    float: left;
    background: transparent !important;
}

#maintoolbar {
    margin-bottom: -3px;
    margin-top: 0px;
    border: 0px;
    min-height: 27px;
    padding-top: 2px;
    padding-bottom: 0px;
}

#maintoolbar .container {
    width: 100%;
    margin-right: auto;
    margin-left: auto;
    background-color: #282828;
    margin-top: -1px;
}

.list_header,
div#notebook_list_header.row.list_header {
    font-size: 9pt;
    color: #f8f8f0;
    background-color: transparent;
    height: 35px;
}

i.fa.fa-folder {
    display: inline-block;
    font: normal normal normal 14px "FontAwesome";
    font-family: "FontAwesome" !important;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    font-size: 18px;
    -moz-osx-font-smoothing: grayscale;
}

#running .panel-group .panel .panel-heading {
    font-size: 14pt;
    color: #f8f8f0;
    padding: 8px 8px;
    background: #2f2f2f;
    background-color: #2f2f2f;
}

#running .panel-group .panel .panel-heading a {
    font-size: 14pt;
    color: #f8f8f0;
}

#running .panel-group .panel .panel-heading a:focus,
#running .panel-group .panel .panel-heading a:hover {
    font-size: 14pt;
    color: #f8f8f0;
}

#running .panel-group .panel .panel-body .list_container .list_item {
    background: #232323;
    background-color: #232323;
    padding: 2px;
    border-bottom: 2px solid rgba(93, 92, 82, .25);
}

#running .panel-group .panel .panel-body .list_container .list_item:hover {
    background: #232323;
    background-color: #232323;
}

#running .panel-group .panel .panel-body {
    padding: 2px;
}

button#refresh_running_list {
    border: none !important;
}

button#refresh_cluster_list {
    border: none !important;
}

div.running_list_info.toolbar_info {
    font-size: 15px;
    padding: 4px 0 4px 0;
    margin-top: 5px;
    margin-bottom: 8px;
    height: 24px;
    line-height: 24px;
    text-shadow: none;
}

.list_placeholder {
    font-weight: normal;
}

#tree-selector {
    padding: 0px;
    border-color: transparent;
}

#project_name>ul>li>a>i.fa.fa-home {
    color: #a6e22e;
    font-size: 17pt;
    display: inline-block;
    position: static;
    padding: 0px 0px;
    font-weight: normal;
    text-align: center;
    vertical-align: text-top;
}

.fa-folder:before {
    color: #ae81ff;
}

.fa-arrow-up:before {
    font-size: 14px;
}

.fa-arrow-down:before {
    font-size: 14px;
}

span#last-modified.btn.btn-xs.btn-default.sort-action:hover .fa,
span#sort-name.btn.btn-xs.btn-default.sort-action:hover .fa {
    color: #a6e22e;
}

.folder_icon:before {
    display: inline-block;
    font: normal normal normal 14px/1 FontAwesome;
    font-size: inherit;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
    content: "\f07b";
    color: #ae81ff;
}

.notebook_icon:before {
    display: inline-block;
    font: normal normal normal 14px/1 FontAwesome;
    font-size: inherit;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
    content: "\f02d";
    position: relative;
    color: #a6e22e !important;
    top: 0px;
}

.file_icon:before {
    display: inline-block;
    font: normal normal normal 14px/1 FontAwesome;
    font-size: inherit;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
    content: "\f15b";
    position: relative;
    top: 0px;
    color: #888888 !important;
}

#project_name a {
    display: inline-flex;
    padding-left: 7px;
    margin-left: -2px;
    text-align: -webkit-auto;
    vertical-align: baseline;
    font-size: 18px;
}

div#notebook_toolbar div.dynamic-instructions {
    font-family: sans-serif;
    font-size: 17px;
    color: #75715e;
}

span#login_widget>.button,
#logout {
    font-family: "Proxima Nova", sans-serif;
    color: #f8f8f0;
    background: transparent;
    background-color: transparent;
    border: 2px solid #2f2f2f;
    font-weight: normal;
    box-shadow: none;
    text-shadow: none;
    border-radius: 3px;
    margin-right: 10px;
    padding: 2px 7px;
}

span#login_widget>.button:hover,
#logout:hover {
    color: #a6e22e;
    background-color: transparent;
    background: transparent;
    border: 2px solid #a6e22e;
    background-image: none;
    box-shadow: none !important;
    border-radius: 3px;
}

span#login_widget>.button:focus,
#logout:focus,
span#login_widget>.button.focus,
#logout.focus,
span#login_widget>.button:active,
#logout:active,
span#login_widget>.button.active,
#logout.active,
.open>.dropdown-togglespan#login_widget>.button,
.open>.dropdown-toggle#logout {
    color: #f8f8f2;
    background-color: #f8f8f0;
    background: #f8f8f0;
    border-color: #f8f8f0;
    background-image: none;
    box-shadow: none !important;
    border-radius: 2px;
}

body>#header #header-container {
    padding-bottom: 0px;
    padding-top: 4px;
    box-sizing: border-box;
    -moz-box-sizing: border-box;
    -webkit-box-sizing: border-box;
}

body>#header {
    background: #1e1e1e;
    background-color: #1e1e1e;
    position: relative;
    z-index: 100;
}

.list_container {
    font-size: 9pt;
    color: #f8f8f0;
    border: none;
    text-shadow: none !important;
}

.list_container>div {
    border-bottom: 1px solid rgba(93, 92, 82, .25);
    font-size: 9pt;
}

.list_header>div,
.list_item>div {
    padding-top: 6px;
    padding-bottom: 2px;
    padding-left: 0px;
}

.list_header>div .item_link,
.list_item>div .item_link {
    margin-left: -1px;
    vertical-align: middle;
    line-height: 22px;
    font-size: 9pt;
}

.item_icon {
    color: #ae81ff;
    font-size: 9pt;
    vertical-align: middle;
}

.list_item input:not([type="checkbox"]) {
    padding-right: 0px;
    height: 1.75em;
    width: 25%;
    margin: 0px 0 0;
    margin-top: 0px;
}

.list_header>div .item_link,
.list_item>div .item_link {
    margin-left: -1px;
    vertical-align: middle;
    line-height: 1.5em;
    font-size: 9pt;
    display: inline-table;
    position: static;
}

#button-select-all {
    height: 34px;
    min-width: 55px;
    z-index: 0;
    border: none !important;
    padding-top: 0px;
    padding-bottom: 0px;
    margin-bottom: 0px;
    margin-top: 0px;
    left: -3px;
    border-radius: 0px !important;
}

#button-select-all:focus,
#button-select-all:active:focus,
#button-select-all.active:focus,
#button-select-all.focus,
#button-select-all:active.focus,
#button-select-all.active.focus {
    background-color: #2f2f2f !important;
    background: #2f2f2f !important;
}

button#tree-selector-btn {
    height: 34px;
    font-size: 12.0pt;
    border: none;
    left: 0px;
    border-radius: 0px !important;
}

input#select-all.pull-left.tree-selector {
    margin-left: 7px;
    margin-right: 2px;
    margin-top: 2px;
    top: 4px;
}

input[type="radio"],
input[type="checkbox"] {
    margin-top: 1px;
    line-height: normal;
}

.delete-button {
    border: none !important;
}

i.fa.fa-trash {
    font-size: 13.5pt;
}

.list_container a {
    font-size: 16px;
    color: #f8f8f0;
    border: none;
    text-shadow: none !important;
    font-weight: normal;
    font-style: normal;
}

div.list_container a:hover {
    color: #f8f8f0;
}

.list_header>div input,
.list_item>div input {
    margin-right: 7px;
    margin-left: 12px;
    vertical-align: baseline;
    line-height: 22px;
    position: relative;
    top: -1px;
}

div.list_item:hover {
    background-color: rgba(93, 92, 82, .1);
}

.breadcrumb>li {
    font-size: 12.0pt;
    color: #f8f8f0;
    border: none;
    text-shadow: none !important;
}

.breadcrumb>li+li:before {
    content: "/\00a0";
    padding: 0px;
    color: #f8f8f0;
    font-size: 18px;
}

#project_name>.breadcrumb {
    padding: 0px;
    margin-bottom: 0px;
    background-color: transparent;
    font-weight: normal;
    margin-top: -2px;
}

ul#tabs a {
    font-family: sans-serif;
    font-size: 9pt;
    font-weight: normal;
    font-style: normal;
    text-shadow: none !important;
}

.nav-tabs {
    font-family: sans-serif;
    font-size: 9pt;
    font-weight: normal;
    font-style: normal;
    background-color: transparent;
    border-color: transparent;
    text-shadow: none !important;
    border: 2px solid transparent;
}

.nav-tabs>li>a:active,
.nav-tabs>li>a:focus,
.nav-tabs>li>a:hover,
.nav-tabs>li.active>a,
.nav-tabs>li.active>a:focus,
.nav-tabs>li.active>a:hover,
.nav-tabs>li.active>a,
.nav-tabs>li.active>a:hover,
.nav-tabs>li.active>a:focus {
    color: #a6e22e;
    background-color: transparent;
    border-color: transparent;
    border-bottom: 2px solid transparent;
}

.nav>li.disabled>a,
.nav>li.disabled>a:hover {
    color: #75715e;
}

.nav-tabs>li>a:before {
    content: "";
    position: absolute;
    width: 100%;
    height: 2px;
    bottom: -2px;
    left: 0;
    background-color: #a6e22e;
    visibility: hidden;
    -webkit-transform: perspective(0)scaleX(0);
    transform: perspective(0)scaleX(0);
    -webkit-transition: ease 220ms;
    transition: ease 220ms;
    -webkit-font-smoothing: antialiased !important;
}

.nav-tabs>li>a:hover:before {
    visibility: visible;
    -webkit-transform: perspective(1)scaleX(1);
    transform: perspective(1)scaleX(1);
}

.nav-tabs>li.active>a:before {
    content: "";
    position: absolute;
    width: 100%;
    height: 2px;
    bottom: -2px;
    left: 0;
    background-color: #a6e22e;
    visibility: visible;
    -webkit-transform: perspective(1)scaleX(1);
    transform: perspective(1)scaleX(1);
    -webkit-font-smoothing: subpixel-antialiased !important;
}

div#notebook {
    font-family: sans-serif;
    font-size: 9pt;
    padding-top: 4px;
}

.notebook_app {
    background-color: #1e1e1e;
}

#notebook-container {
    padding: 13px 2px;
    background-color: #1e1e1e;
    min-height: 0px;
    box-shadow: none;
    width: 1260px;
    margin-right: auto;
    margin-left: auto;
}

div#ipython-main-app.container {
    width: 1260px;
    margin-right: auto;
    margin-left: auto;
    margin-right: auto;
    margin-left: auto;
}

.container {
    width: 1260px;
    margin-right: auto;
    margin-left: auto;
}

div#menubar-container {
    width: 100%;
    width: 980px;
}

div#header-container {
    width: 980px;
}

.notebook_app #header,
.edit_app #header {
    box-shadow: none !important;
    background-color: #1e1e1e;
    border-bottom: 2px solid rgba(93, 92, 82, .25);
}

#header,
.edit_app #header {
    font-family: sans-serif;
    font-size: 9pt;
    box-shadow: none;
    background-color: #1e1e1e;
}

#header .header-bar,
.edit_app #header .header-bar {
    background: #1e1e1e;
    background-color: #1e1e1e;
}

body>#header .header-bar {
    width: 100%;
    background: #1e1e1e;
}

span.checkpoint_status,
span.autosave_status {
    font-size: small;
    display: none;
}

#menubar,
div#menubar {
    background-color: #1e1e1e;
    padding-top: 0px !important;
}

#menubar .navbar,
.navbar-default {
    background-color: #1e1e1e;
    margin-bottom: 0px;
    margin-top: 0px;
}

.navbar {
    border: none;
}

div.navbar-text,
.navbar-text,
.navbar-text.indicator_area,
p.navbar-text.indicator_area {
    margin-top: 8px !important;
    margin-bottom: 0px;
    color: #a6e22e;
}

.navbar-default {
    font-family: sans-serif;
    font-size: 9pt;
    background-color: #1e1e1e;
    border-color: rgba(93, 92, 82, .25);
    line-height: 1.5em;
    padding-bottom: 0px;
}

.navbar-default .navbar-nav>li>a {
    font-family: sans-serif;
    font-size: 9pt;
    color: #f8f8f0;
    display: block;
    line-height: 1.5em;
    padding-top: 14px;
    padding-bottom: 11px;
}

.navbar-default .navbar-nav>li>a:hover,
.navbar-default .navbar-nav>li>a:focus {
    color: #f8f8f0 !important;
    background-color: rgba(93, 92, 82, .25) !important;
    border-color: rgba(93, 92, 82, .25) !important;
    line-height: 1.5em;
    transition: 80ms ease;
}

.navbar-default .navbar-nav>.open>a,
.navbar-default .navbar-nav>.open>a:hover,
.navbar-default .navbar-nav>.open>a:focus {
    color: #f8f8f2;
    background-color: #383838;
    border-color: #383838;
    line-height: 1.5em;
}

.navbar-nav>li>.dropdown-menu {
    margin-top: 0px;
}

.navbar-nav {
    margin: 0;
}

div.notification_widget.info,
.notification_widget.info,
.notification_widget:active:hover,
.notification_widget.active:hover,
.open>.dropdown-toggle.notification_widget:hover,
.notification_widget:active:focus,
.notification_widget.active:focus,
.open>.dropdown-toggle.notification_widget:focus,
.notification_widget:active.focus,
.notification_widget.active.focus,
.open>.dropdown-toggle.notification_widget.focus,
div#notification_notebook.notification_widget.btn.btn-xs.navbar-btn,
div#notification_notebook.notification_widget.btn.btn-xs.navbar-btn:hover,
div#notification_notebook.notification_widget.btn.btn-xs.navbar-btn:focus {
    color: #f8f8f0 !important;
    background-color: transparent !important;
    border-color: transparent !important;
    padding-bottom: 0px !important;
    margin-bottom: 0px !important;
    font-size: 9pt !important;
    z-index: 0;
}

div#notification_notebook.notification_widget.btn.btn-xs.navbar-btn {
    font-size: 9pt !important;
    z-index: 0;
}

.notification_widget {
    color: #ae81ff;
    z-index: -500;
    font-size: 9pt;
    background: transparent;
    background-color: transparent;
    margin-right: 3px;
    border: none;
}

.notification_widget,
div.notification_widget {
    margin-right: 0px;
    margin-left: 0px;
    padding-right: 0px;
    vertical-align: text-top !important;
    margin-top: 6px !important;
    background: transparent !important;
    background-color: transparent !important;
    font-size: 9pt !important;
    border: none;
}

.navbar-btn.btn-xs:hover {
    border: none !important;
    background: transparent !important;
    background-color: transparent !important;
    color: #f8f8f0 !important;
}

div.notification_widget.info,
.notification_widget.info {
    display: none !important;
}

.edit_mode .modal_indicator:before {
    display: none;
}

.command_mode .modal_indicator:before {
    display: none;
}

.item_icon {
    color: #ae81ff;
}

.item_buttons .kernel-name {
    font-size: 9pt;
    color: #ae81ff;
}

.running_notebook_icon:before {
    color: #a6e22e !important;
    font: normal normal normal 15px/1 FontAwesome;
    font-size: 15px;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
    content: "\f10c";
    vertical-align: middle;
    position: static;
    display: inherit;
}

.item_buttons .running-indicator {
    padding-top: 4px;
    color: #a6e22e;
    font-family: sans-serif;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
}

#notification_trusted {
    font-family: sans-serif;
    border: none;
    background: transparent;
    background-color: transparent;
    margin-bottom: 0px !important;
    vertical-align: bottom !important;
    color: #75715e !important;
    cursor: default !important;
}

#notification_area,
div.notification_area {
    float: right !important;
    position: static;
    cursor: pointer;
    padding-top: 6px;
    padding-right: 4px;
}

div#notification_notebook.notification_widget.btn.btn-xs.navbar-btn {
    font-size: 9pt !important;
    z-index: 0;
    margin-top: -5px !important;
}

#modal_indicator {
    float: right !important;
    color: #4c8be2;
    background: #1e1e1e;
    background-color: #1e1e1e;
    margin-top: 8px !important;
    margin-left: 0px;
}

#kernel_indicator {
    float: right !important;
    color: #a6e22e;
    background: #1e1e1e;
    background-color: #1e1e1e;
    border-left: 2px solid #a6e22e;
    padding-top: 0px;
    padding-bottom: 4px;
    margin-top: 10px !important;
    margin-left: -2px;
    padding-left: 5px !important;
}

#kernel_indicator .kernel_indicator_name {
    font-size: 12px;
    color: #a6e22e;
    background: #1e1e1e;
    background-color: #1e1e1e;
    padding-left: 5px;
    padding-right: 5px;
    margin-top: 4px;
    vertical-align: text-top;
    padding-bottom: 0px;
}

.kernel_idle_icon:before {
    display: inline-block;
    font: normal normal normal 22px/1 FontAwesome;
    font-size: 22px;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    cursor: pointer;
    margin-left: 0px !important;
    opacity: 0.7;
    vertical-align: bottom;
    margin-top: 1px;
    content: "\f1db";
}

.kernel_busy_icon:before {
    display: inline-block;
    font: normal normal normal 22px/1 FontAwesome;
    font-size: 22px;
    -webkit-animation: pulsate 2s infinite ease-out;
    animation: pulsate 2s infinite ease-out;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    cursor: pointer;
    margin-left: 0px !important;
    vertical-align: bottom;
    margin-top: 1px;
    content: "\f111";
}

@-webkit-keyframes pulsate {
    0% {
        -webkit-transform: scale(1.0, 1.0);
        opacity: 0.8;
    }

    8% {
        -webkit-transform: scale(1.0, 1.0);
        opacity: 0.8;
    }

    50% {
        -webkit-transform: scale(0.75, 0.75);
        opacity: 0.3;
    }

    92% {
        -webkit-transform: scale(1.0, 1.0);
        opacity: 0.8;
    }

    100% {
        -webkit-transform: scale(1.0, 1.0);
        opacity: 0.8;
    }
}

div.notification_widget.info,
.notification_widget.info,
.notification_widget:active:hover,
.notification_widget.active:hover,
.open>.dropdown-toggle.notification_widget:hover,
.notification_widget:active:focus,
.notification_widget.active:focus,
.open>.dropdown-toggle.notification_widget:focus,
.notification_widget:active.focus,
.notification_widget.active.focus,
.open>.dropdown-toggle.notification_widget.focus,
div#notification_notebook.notification_widget.btn.btn-xs.navbar-btn,
div#notification_notebook.notification_widget.btn.btn-xs.navbar-btn:hover,
div#notification_notebook.notification_widget.btn.btn-xs.navbar-btn:focus {
    color: #f8f8f0;
    background-color: #1e1e1e;
    border-color: #1e1e1e;
}

#notification_area,
div.notification_area {
    float: right !important;
    position: static;
}

.notification_widget,
div.notification_widget {
    margin-right: 0px;
    margin-left: 0px;
    padding-right: 0px;
    vertical-align: text-top !important;
    margin-top: 6px !important;
    z-index: 1000;
}

#kernel_logo_widget,
#kernel_logo_widget .current_kernel_logo {
    display: none;
}

div#ipython_notebook {
    display: none;
}

i.fa.fa-icon {
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
    text-rendering: auto;
}

.fa {
    display: inline-block;
    font: normal normal normal 10pt/1 "FontAwesome", sans-serif;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
}

.dropdown-menu {
    font-family: sans-serif;
    font-size: 9pt;
    box-shadow: none;
    padding: 0px;
    text-align: left;
    border: none;
    background-color: #383838;
    background: #383838;
    line-height: 1;
}

.dropdown-menu:hover {
    font-family: sans-serif;
    font-size: 9pt;
    box-shadow: none;
    padding: 0px;
    text-align: left;
    border: none;
    background-color: #383838;
    box-shadow: none;
    line-height: 1;
}

.dropdown-menu>li>a {
    font-family: sans-serif;
    font-size: 9.0pt;
    display: block;
    padding: 10px 20px 9px 10px;
    color: #f8f8f0;
    background-color: #383838;
    background: #383838;
}

.dropdown-menu>li>a:hover,
.dropdown-menu>li>a:focus {
    color: #f8f8f0;
    background-color: rgba(93, 92, 82, .25);
    background: rgba(93, 92, 82, .25);
    border-color: rgba(93, 92, 82, .25);
    transition: 200ms ease;
}

.dropdown-menu .divider {
    height: 1px;
    margin: 0px 0px;
    overflow: hidden;
    background-color: rgba(93, 92, 82, .5);
}

.dropdown-submenu>.dropdown-menu {
    display: none;
    top: 2px !important;
    left: 100%;
    margin-top: -2px;
    margin-left: 0px;
    padding-top: 0px;
    transition: 200ms ease;
}

.dropdown-menu>.disabled>a,
.dropdown-menu>.disabled>a:hover,
.dropdown-menu>.disabled>a:focus {
    font-family: sans-serif;
    font-size: 12.0pt;
    font-weight: normal;
    color: #75715e;
    padding: none;
    display: block;
    clear: both;
    white-space: nowrap;
}

.dropdown-submenu>a:after {
    color: #f8f8f0;
    margin-right: -16px;
    margin-top: 0px;
    display: inline-block;
}

.dropdown-submenu:hover>a:after,
.dropdown-submenu:active>a:after,
.dropdown-submenu:focus>a:after,
.dropdown-submenu:visited>a:after {
    color: #a6e22e;
    margin-right: -16px;
    display: inline-block !important;
}

div.kse-dropdown>.dropdown-menu,
.kse-dropdown>.dropdown-menu {
    min-width: 0;
    top: 94%;
}

.btn,
.btn-default {
    font-family: sans-serif;
    color: #f8f8f0;
    background: #2f2f2f;
    background-color: #2f2f2f;
    border: 2px solid #2f2f2f;
    font-weight: normal;
    box-shadow: none;
    text-shadow: none;
    border-radius: 3px;
    font-size: initial;
}

.btn:hover,
.btn:active:hover,
.btn.active:hover,
.btn-default:hover,
.open>.dropdown-toggle.btn-default:hover,
.open>.dropdown-toggle.btn:hover {
    color: #a6e22e;
    border: 2px solid #2a2a2a;
    background-color: #2a2a2a;
    background: #2a2a2a;
    background-image: none;
    box-shadow: none !important;
    border-radius: 3px;
}

.btn:active,
.btn.active,
.btn:active:focus,
.btn.active:focus,
.btn:active.focus,
.btn.active.focus,
.btn-default:focus,
.btn-default.focus,
.btn-default:active,
.btn-default.active,
.btn-default:active:hover,
.btn-default.active:hover,
.btn-default:active:focus,
.btn-default.active:focus,
.btn-default:active.focus,
.btn-default.active.focus,
.open>.dropdown-toggle.btn:focus,
.open>.dropdown-toggle.btn.focus,
.open>.dropdown-toggle.btn-default:hover,
.open>.dropdown-toggle.btn-default:focus,
.open>.dropdown-toggle.btn-default.hover,
.open>.dropdown-toggle.btn-default.focus {
    color: #a6e22e;
    border: 2px solid #2a2a2a;
    background-color: #2a2a2a !important;
    background: #2a2a2a !important;
    background-image: none;
    box-shadow: none !important;
    border-radius: 3px;
}

.btn-default:active:hover,
.btn-default.active:hover,
.btn-default:active:focus,
.btn-default.active:focus,
.btn-default:active.focus,
.btn-default.active.focus {
    color: #a6e22e !important;
    background-color: #2f2f2f;
    border-color: #546745 !important;
    transition: 2000ms ease;
}

.btn:focus,
.btn.focus,
.btn:active:focus,
.btn.active:focus,
.btn:active,
.btn.active,
.btn:active.focus,
.btn.active.focus {
    color: #a6e22e !important;
    outline: none !important;
    outline-width: 0px !important;
    background: #546745 !important;
    background-color: #546745 !important;
    border-color: #546745 !important;
    transition: 200ms ease !important;
}

.item_buttons>.btn,
.item_buttons>.btn-group,
.item_buttons>.input-group {
    font-size: 9pt;
    background: transparent;
    background-color: transparent;
    border: 0px solid #2f2f2f;
    border-bottom: 2px solid transparent;
    margin-left: 5px;
    padding-top: 4px !important;
}

.item_buttons>.btn:hover,
.item_buttons>.btn-group:hover,
.item_buttons>.input-group:hover,
.item_buttons>.btn.active,
.item_buttons>.btn-group.active,
.item_buttons>.input-group.active,
.item_buttons>.btn.focus {
    margin-left: 5px;
    background: #2a2a2a;
    padding-top: 4px !important;
    background-color: transparent;
    border: 0px solid transparent;
    border-bottom: 2px solid #a6e22e;
    border-radius: 0px;
    transition: none;
}

.item_buttons {
    line-height: 1.5em !important;
}

.item_buttons .btn {
    min-width: 11ex;
}

.btn-group>.btn:first-child {
    margin-left: 3px;
}

.btn-group>.btn-mini,
.btn-sm,
.btn-group-sm>.btn,
.btn-xs,
.btn-group-xs>.btn,
.alternate_upload .btn-upload,
.btn-group,
.btn-group-vertical {
    font-size: inherit;
    font-weight: normal;
    height: inherit;
    line-height: inherit;
}

.btn-xs,
.btn-group-xs>.btn {
    font-size: initial !important;
    background-image: none;
    font-weight: normal;
    text-shadow: none;
    display: inline-table;
    padding: 2px 5px;
    line-height: 1.45;
}

.btn-group>.btn:first-child {
    margin-left: 3px;
}

div#new-buttons>button,
#new-buttons>button,
div#refresh_notebook_list,
#refresh_notebook_list {
    background: transparent;
    background-color: transparent;
    border: none;
}

div#new-buttons>button:hover,
#new-buttons>button:hover,
div#refresh_notebook_list,
#refresh_notebook_list,
div.alternate_upload .btn-upload,
.alternate_upload .btn-upload,
div.dynamic-buttons>button,
.dynamic-buttons>button,
.dynamic-buttons>button:focus,
.dynamic-buttons>button:active:focus,
.dynamic-buttons>button.active:focus,
.dynamic-buttons>button.focus,
.dynamic-buttons>button:active.focus,
.dynamic-buttons>button.active.focus,
#new-buttons>button:focus,
#new-buttons>button:active:focus,
#new-buttons>button.active:focus,
#new-buttons>button.focus,
#new-buttons>button:active.focus,
#new-buttons>button.active.focus,
.alternate_upload .btn-upload:focus,
.alternate_upload .btn-upload:active:focus,
.alternate_upload .btn-upload.active:focus,
.alternate_upload .btn-upload.focus,
.alternate_upload .btn-upload:active.focus,
.alternate_upload .btn-upload.active.focus {
    background: transparent !important;
    background-color: transparent !important;
    border: none !important;
}

.alternate_upload input.fileinput {
    text-align: center;
    vertical-align: bottom;
    margin-left: -.5ex;
    display: inline-table;
    border: solid 0px #2f2f2f;
    margin-bottom: -1ex;
}

.alternate_upload .btn-upload {
    display: inline-table;
    background: transparent;
    border: none;
}

.btn-group .btn+.btn,
.btn-group .btn+.btn-group,
.btn-group .btn-group+.btn,
.btn-group .btn-group+.btn-group {
    margin-left: -2px;
}

.btn-group>.btn:first-child:not(:last-child):not(.dropdown-toggle) {
    border-bottom-right-radius: 0;
    border-top-right-radius: 0;
    z-index: 2;
}

.dropdown-header {
    font-family: sans-serif !important;
    font-size: 9pt !important;
    color: #a6e22e !important;
    border-bottom: none !important;
    padding: 0px !important;
    margin: 6px 6px 0px !important;
}

span#last-modified.btn.btn-xs.btn-default.sort-action,
span#sort-name.btn.btn-xs.btn-default.sort-action,
span#file-size.btn.btn-xs.btn-default.sort-action {
    font-family: sans-serif;
    font-size: 16px;
    background-color: transparent;
    background: transparent;
    border: none;
    color: #f8f8f0;
    padding-bottom: 0px;
    margin-bottom: 0px;
    vertical-align: sub;
}

span#last-modified.btn.btn-xs.btn-default.sort-action {
    margin-left: 19px;
}

button.close {
    border: 0px none;
    font-family: sans-serif;
    font-size: 20pt;
    font-weight: normal;
}

.dynamic-buttons {
    padding-top: 0px;
    display: inline-block;
}

.close {
    color: #f92672;
    opacity: .5;
    text-shadow: none;
    font-weight: normal;
}

.close:hover {
    color: #f92672;
    opacity: 1;
    font-weight: normal;
}

div.nbext-enable-btns .btn[disabled],
div.nbext-enable-btns .btn[disabled]:hover,
.btn-default.disabled,
.btn-default[disabled],
.btn-default.disabled:hover,
.btn-default[disabled]:hover,
fieldset[disabled] .btn-default:hover,
.btn-default.disabled:focus,
.btn-default[disabled]:focus,
fieldset[disabled] .btn-default:focus,
.btn-default.disabled.focus,
.btn-default[disabled].focus,
fieldset[disabled] .btn-default.focus {
    color: #888888;
    background: #2c2c2c;
    background-color: #2c2c2c;
    border-color: #2c2c2c;
    transition: 200ms ease;
}

.input-group-addon {
    padding: 2px 5px;
    font-size: 9pt;
    font-weight: normal;
    height: auto;
    color: #f8f8f0;
    text-align: center;
    background-color: transparent;
    border: 2px solid transparent !important;
    text-transform: capitalize;
}

a.btn.btn-default.input-group-addon:hover {
    background: transparent !important;
    background-color: transparent !important;
}

.btn-group>.btn+.dropdown-toggle {
    padding-left: 8px;
    padding-right: 8px;
    height: 100%;
}

.btn-group>.btn+.dropdown-toggle:hover {
    background: #2a2a2a !important;
}

.input-group-btn {
    position: relative;
    font-size: inherit;
    white-space: nowrap;
    background: #2f2f2f;
    background-color: #2f2f2f;
    border: none;
}

.input-group-btn:hover {
    background: #2a2a2a;
    background-color: #2a2a2a;
    border: none;
}

.input-group-btn:first-child>.btn,
.input-group-btn:first-child>.btn-group {
    background: #2f2f2f;
    background-color: #2f2f2f;
    border: none;
    margin-left: 2px;
    margin-right: -1px;
    font-size: inherit;
}

.input-group-btn:first-child>.btn:hover,
.input-group-btn:first-child>.btn-group:hover {
    background: #2a2a2a;
    background-color: #2a2a2a;
    border: none;
    font-size: inherit;
    transition: 200ms ease;
}

div.modal .btn-group>.btn:first-child {
    background: #2f2f2f;
    background-color: #2f2f2f;
    border: 1px solid #2c2c2c;
    margin-top: 0px !important;
    margin-left: 0px;
    margin-bottom: 2px;
}

div.modal .btn-group>.btn:first-child:hover {
    background: #2a2a2a;
    background-color: #2a2a2a;
    border: 1px solid #2a2a2a;
    transition: 200ms ease;
}

div.modal>button,
div.modal-footer>button {
    background: #2f2f2f;
    background-color: #2f2f2f;
    border-color: #2f2f2f;
}

div.modal>button:hover,
div.modal-footer>button:hover {
    background: #2a2a2a;
    background-color: #2a2a2a;
    border-color: #2a2a2a;
    transition: 200ms ease;
}

.modal-content {
    font-family: sans-serif;
    font-size: 12.0pt;
    position: relative;
    background: #2f2f2f;
    background-color: #2f2f2f;
    border: none;
    border-radius: 1px;
    background-clip: padding-box;
    outline: none;
}

.modal-header {
    font-family: sans-serif;
    font-size: 9pt;
    color: #f8f8f0;
    background: #2f2f2f;
    background-color: #2f2f2f;
    border-color: rgba(93, 92, 82, .25);
    padding: 12px;
    min-height: 16.4286px;
}

.modal-content h4 {
    font-family: sans-serif;
    font-size: 16pt;
    color: #f8f8f0;
    padding: 5px;
}

.modal-body {
    background-color: #232323;
    position: relative;
    padding: 15px;
}

.modal-footer {
    padding: 8px;
    text-align: right;
    background-color: #232323;
    border-top: none;
}

.alert-info {
    background-color: #2f2f2f;
    border-color: rgba(93, 92, 82, .25);
    color: #f8f8f0;
}

.modal-header .close {
    margin-top: -5px;
    font-size: 25pt;
}

.modal-backdrop,
.modal-backdrop.in {
    opacity: 0.85;
    background-color: notebook-bg;
}

div.panel,
div.panel-default,
.panel,
.panel-default {
    font-family: sans-serif;
    font-size: 9pt;
    background-color: #232323;
    color: #f8f8f0;
    margin-bottom: 14px;
    border: 0;
    box-shadow: none;
}

div.panel>.panel-heading,
div.panel-default>.panel-heading {
    font-size: 14pt;
    color: #f8f8f0;
    background: #2f2f2f;
    background-color: #2f2f2f;
    border: 0;
}

.modal .modal-dialog {
    min-width: 950px;
    margin: 50px auto;
}

div.container-fluid {
    margin-right: auto;
    margin-left: auto;
    padding-left: 0px;
    padding-right: 5px;
}

div.form-control,
.form-control {
    font-family: sans-serif;
    font-size: initial;
    color: #f8f8f0;
    background-color: #282828;
    border: 1px solid #282828 !important;
    margin-left: 2px;
    box-shadow: none;
    transition: border-color 0.15s ease-in-out 0s, box-shadow 0.15s ease-in-out 0s;
}

.form-control-static {
    min-height: inherit;
    height: inherit;
}

.form-group.list-group-item {
    color: #f8f8f0;
    background-color: #232323;
    border-color: rgba(93, 92, 82, .25);
    margin-bottom: 0px;
}

.form-group .input-group {
    float: left;
}

input,
button,
select,
textarea {
    background-color: #282828;
    font-weight: normal;
    border: 1px solid rgba(93, 92, 82, .25);
}

select.form-control.select-xs {
    height: 33px;
    font-size: 9pt;
}

.toolbar select,
.toolbar label {
    width: auto;
    vertical-align: middle;
    margin-right: 0px;
    margin-bottom: 0px;
    display: inline;
    font-size: 92%;
    margin-left: 10px;
    padding: 0px;
    background: #2f2f2f !important;
    background-color: #2f2f2f !important;
    border: 2px solid #2f2f2f !important;
}

.form-control:focus {
    border-color: #a6e22e;
    outline: 2px solid #49483e;
    -webkit-box-shadow: none;
}

::-webkit-input-placeholder {
    color: #75715e;
}

::-moz-placeholder {
    color: #75715e;
}

:-ms-input-placeholder {
    color: #75715e;
}

:-moz-placeholder {
    color: #75715e;
}

[dir="ltr"] #find-and-replace .input-group-btn+.form-control {
    border: 2px solid rgba(93, 92, 82, .25) !important;
}

[dir="ltr"] #find-and-replace .input-group-btn+.form-control:focus {
    border-color: #a6e22e;
    outline: 2px solid #49483e;
    -webkit-box-shadow: none;
    box-shadow: none;
}

div.output.output_scroll {
    box-shadow: none;
}

::-webkit-scrollbar {
    width: 11px;
    max-height: 9px;
    background-color: #2d2d2d;
    border-radius: 3px;
    border: none;
}

::-webkit-scrollbar-track {
    background: #2d2d2d;
    border: none;
    width: 11px;
    max-height: 9px;
}

::-webkit-scrollbar-thumb {
    border-radius: 2px;
    border: none;
    background: #49483e;
    background-clip: content-box;
    width: 11px;
}

HTML,
body,
div,
dl,
dt,
dd,
ul,
ol,
li,
h1,
h2,
h3,
h4,
h5,
h6,
pre,
code,
form,
fieldset,
legend,
input,
button,
textarea,
p,
blockquote,
th,
td,
span,
a {
    text-rendering: geometricPrecision;
    -webkit-font-smoothing: subpixel-antialiased;
    font-weight: 400;
}

div.input_area {
    background-color: #282828;
    background: #282828;
    padding-right: 1.2em;
    border: 0px;
    border-radius: 0px;
    border-top-right-radius: 4px;
    border-bottom-right-radius: 4px;
}

div.cell {
    padding: 0px;
    background: #282828;
    background-color: #282828;
    border: medium solid #1e1e1e;
    border-radius: 4px;
    top: 0;
}

div.cell.selected {
    background: #282828;
    background-color: #282828;
    border: medium solid #1e1e1e;
    padding: 0px;
    border-radius: 5px;
}

.edit_mode div.cell.selected {
    padding: 0px;
    background: #282828;
    background-color: #282828;
    border: medium solid #1e1e1e;
    border-radius: 5px;
}

div.cell.edit_mode {
    padding: 0px;
    background: #282828;
    background-color: #282828;
}

div.CodeMirror-sizer {
    margin-left: 0px;
    margin-bottom: -21px;
    border-right-width: 16px;
    min-height: 37px;
    padding-right: 0px;
    padding-bottom: 0px;
    margin-top: 0px;
}

div.cell.selected:before,
.edit_mode div.cell.selected:before,
div.cell.selected:before,
div.cell.selected.jupyter-soft-selected:before {
    background: #282828 !important;
    border: none;
    border-radius: 3px;
    position: absolute;
    display: block;
    top: 0px;
    left: 0px;
    width: 0px;
    height: 100%;
}

div.cell.text_cell.selected::before,
.edit_mode div.cell.text_cell.selected:before,
div.cell.text_cell.selected:before,
div.cell.text_cell.selected.jupyter-soft-selected:before {
    background: #282828 !important;
    background-color: #282828 !important;
    border-color: #57564b !important;
}

div.cell.code_cell .input {
    border-left: 5px solid #282828 !important;
    border-radius: 3px;
    border-bottom-left-radius: 3px;
    border-top-left-radius: 3px;
}

div.cell.code_cell.selected .input {
    border-left: 5px solid #57564b !important;
    border-radius: 3px;
}

.edit_mode div.cell.code_cell.selected .input {
    border-left: 5px solid #33322b !important;
    border-radius: 3px;
}

.edit_mode div.cell.selected:before {
    height: 100%;
    border-left: 5px solid #33322b !important;
    border-radius: 3px;
}

div.cell.jupyter-soft-selected,
div.cell.selected.jupyter-soft-selected {
    border-left-color: #33322b !important;
    border-left-width: 0px !important;
    padding-left: 7px !important;
    border-right-color: #33322b !important;
    border-right-width: 0px !important;
    background: #33322b !important;
    border-radius: 6px !important;
}

div.cell.selected.jupyter-soft-selected .input {
    border-left: 5px solid #282828 !important;
}

div.cell.selected.jupyter-soft-selected {
    border-left-color: #57564b;
    border-color: #1e1e1e;
    padding-left: 7px;
    border-radius: 6px;
}

div.cell.code_cell.selected .input {
    border-left: none;
    border-radius: 3px;
}

div.cell.selected.jupyter-soft-selected .prompt,
div.cell.text_cell.selected.jupyter-soft-selected .prompt {
    top: 0;
    border-left: #282828 !important;
    border-radius: 2px;
}

div.cell.text_cell.selected.jupyter-soft-selected .input_prompt {
    border-left: none !important;
}

div.cell.text_cell.jupyter-soft-selected,
div.cell.text_cell.selected.jupyter-soft-selected {
    border-left-color: #33322b !important;
    border-left-width: 0px !important;
    padding-left: 26px !important;
    border-right-color: #33322b !important;
    border-right-width: 0px !important;
    background: #33322b !important;
    border-radius: 5px !important;
}

div.cell.jupyter-soft-selected .input,
div.cell.selected.jupyter-soft-selected .input {
    border-left-color: #33322b !important;
}

div.prompt,
.prompt {
    font-family: monospace, monospace;
    font-size: 9pt !important;
    font-weight: normal;
    color: #75715e;
    line-height: 170%;
    padding: 0px;
    padding-top: 4px;
    padding-left: 0px;
    padding-right: 1px;
    text-align: right !important;
    min-width: 11.5ex !important;
    width: 11.5ex !important;
}

div.prompt.input_prompt {
    font-size: 9pt !important;
    background-color: #282828;
    border-top: 0px;
    border-top-right-radius: 0px;
    border-bottom-left-radius: 0px;
    border-bottom-right-radius: 0px;
    padding-right: 3px;
    min-width: 11.5ex;
    width: 11.5ex !important;
}

div.cell.code_cell .input_prompt {
    border-right: 2px solid #49483e;
}

div.cell.selected .prompt {
    top: 0;
}

.edit_mode div.cell.selected .prompt {
    top: 0;
}

.edit_mode div.cell.selected .prompt {
    top: 0;
}

.run_this_cell {
    visibility: hidden;
    color: transparent;
    padding-top: 0px;
    padding-bottom: 0px;
    padding-left: 3px;
    padding-right: 12px;
    width: 1.5ex;
    width: 0ex;
    background: transparent;
    background-color: transparent;
}

div.code_cell:hover div.input .run_this_cell {
    visibility: visible;
}

div.cell.code_cell.rendered.selected .run_this_cell:hover {
    background-color: #1e1e1e;
    background: #1e1e1e;
    color: #57564b !important;
}

div.cell.code_cell.rendered.unselected .run_this_cell:hover {
    background-color: #1e1e1e;
    background: #1e1e1e;
    color: #57564b !important;
}

i.fa-step-forward.fa {
    display: inline-block;
    font: normal normal normal 9px "FontAwesome";
}

.fa-step-forward:before {
    content: "\f04b";
}

div.cell.selected.jupyter-soft-selected .run_this_cell,
div.cell.selected.jupyter-soft-selected .run_this_cell:hover,
div.cell.unselected.jupyter-soft-selected .run_this_cell:hover,
div.cell.code_cell.rendered.selected.jupyter-soft-selected .run_this_cell:hover,
div.cell.code_cell.rendered.unselected.jupyter-soft-selected .run_this_cell:hover {
    background-color: #33322b !important;
    background: #33322b !important;
    color: #33322b !important;
}

div.output_wrapper {
    background-color: #232323;
    border: 0px;
    left: 0px;
    margin-bottom: 0em;
    margin-top: 0em;
    border-top-right-radius: 0px;
    border-top-left-radius: 0px;
}

div.output_subarea.output_text.output_stream.output_stdout,
div.output_subarea.output_text {
    font-family: monospace, monospace;
    font-size: 8.5pt !important;
    line-height: 150% !important;
    background-color: #232323;
    color: #cccccc;
    border-top-right-radius: 0px;
    border-top-left-radius: 0px;
    margin-left: 11.5px;
}

div.output_area pre {
    font-family: monospace, monospace;
    font-size: 8.5pt !important;
    line-height: 151% !important;
    color: #cccccc;
    border-top-right-radius: 0px;
    border-top-left-radius: 0px;
}

div.output_area {
    display: -webkit-box;
}

div.output_html {
    font-family: monospace, monospace;
    font-size: 8.5pt;
    color: #cccccc;
    background-color: #232323;
    background: #232323;
}

div.output_subarea {
    overflow-x: auto;
    padding: 1.2em !important;
    -webkit-box-flex: 1;
    -moz-box-flex: 1;
    box-flex: 1;
    flex: 1;
}

div.btn.btn-default.output_collapsed {
    background: #222222;
    background-color: #222222;
    border-color: #222222;
}

div.btn.btn-default.output_collapsed:hover {
    background: #1d1d1d;
    background-color: #1d1d1d;
    border-color: #1d1d1d;
}

div.prompt.output_prompt {
    font-family: monospace, monospace;
    font-weight: bold !important;
    background-color: #232323;
    color: transparent;
    border-bottom-left-radius: 4px;
    border-top-right-radius: 0px;
    border-top-left-radius: 0px;
    border-bottom-right-radius: 0px;
    min-width: 11.5ex !important;
    width: 11.5ex !important;
    border-right: 2px solid transparent;
}

div.out_prompt_overlay.prompt {
    font-family: monospace, monospace;
    font-weight: bold !important;
    background-color: #232323;
    border-bottom-left-radius: 2px;
    border-top-right-radius: 0px;
    border-top-left-radius: 0px;
    border-bottom-right-radius: 0px;
    min-width: 11.5ex !important;
    width: 11.5ex !important;
    border-right: 2px solid transparent;
    color: transparent;
}

div.out_prompt_overlay.prompt:hover {
    background-color: #49483e;
    box-shadow: none !important;
    border: none;
    border-bottom-left-radius: 2px;
    -webkit-border-: 2px;
    -moz-border-radius: 2px;
    border-top-right-radius: 0px;
    border-top-left-radius: 0px;
    min-width: 11.5ex !important;
    width: 11.5ex !important;
    border-right: 2px solid #49483e !important;
}

div.cell.code_cell .output_prompt {
    border-right: 2px solid transparent;
    color: transparent;
}

div.cell.selected .output_prompt,
div.cell.selected .out_prompt_overlay.prompt {
    border-left: 5px solid #33322b;
    border-right: 2px solid #232323;
    border-radius: 0px !important;
}

.edit_mode div.cell.selected .output_prompt,
.edit_mode div.cell.selected .out_prompt_overlay.prompt {
    border-left: 5px solid #33322b;
    border-right: 2px solid #232323;
    border-radius: 0px !important;
}

div.text_cell,
div.text_cell_render pre,
div.text_cell_render {
    font-family: sans-serif;
    font-size: 9pt;
    line-height: 130% !important;
    color: #f8f8f0;
    background: #282828;
    background-color: #282828;
    border-radius: 0px;
}

div .text_cell_render {
    padding: 0.4em 0.4em 0.4em 0.4em;
}

div.cell.text_cell .CodeMirror-lines {
    padding-top: .7em !important;
    padding-bottom: .4em !important;
    padding-left: .5em !important;
    padding-right: .5em !important;
    margin-top: .4em;
    margin-bottom: .3em;
}

div.cell.text_cell.unrendered div.input_area,
div.cell.text_cell.rendered div.input_area {
    background-color: #282828;
    background: #282828;
    border: 0px;
    border-radius: 2px;
}

div.cell.text_cell .CodeMirror,
div.cell.text_cell .CodeMirror pre {
    line-height: 170% !important;
}

div.cell.text_cell.rendered.selected {
    font-family: sans-serif;
    line-height: 170% !important;
    background: #282828;
    background-color: #282828;
    border-radius: 0px;
}

div.cell.text_cell.unrendered.selected {
    font-family: sans-serif;
    line-height: 170% !important;
    background: #282828;
    background-color: #282828;
    border-radius: 0px;
}

div.cell.text_cell.selected {
    font-family: sans-serif;
    line-height: 170% !important;
    background: #282828;
    background-color: #282828;
    border-radius: 0px;
}

.edit_mode div.cell.text_cell.selected {
    font-family: sans-serif;
    line-height: 170% !important;
    background: #282828;
    background-color: #282828;
    border-radius: 0px;
}

div.text_cell.unrendered,
div.text_cell.unrendered.selected,
div.edit_mode div.text_cell.unrendered {
    font-family: sans-serif;
    line-height: 170% !important;
    background: #282828;
    background-color: #282828;
    border-radius: 0px;
}

div.cell.text_cell .prompt {
    border-right: 0;
    min-width: 11.5ex !important;
    width: 11.5ex !important;
}

div.cell.text_cell.rendered .prompt {
    font-family: monospace, monospace;
    font-size: 9.5pt !important;
    font-weight: normal;
    color: #75715e !important;
    text-align: right !important;
    min-width: 14.5ex !important;
    width: 14.5ex !important;
    background-color: #282828;
    border-right: 2px solid #49483e;
    border-left: 4px solid #282828;
}

div.cell.text_cell.unrendered .prompt {
    font-family: monospace, monospace;
    font-size: 9.5pt !important;
    font-weight: normal;
    color: #75715e !important;
    text-align: right !important;
    min-width: 14.5ex !important;
    width: 14.5ex !important;
    border-right: 2px solid #49483e;
    border-left: 4px solid #282828;
    background-color: #282828;
}

div.cell.text_cell.rendered .prompt {
    border-right: 2px solid #49483e;
}

div.cell.text_cell.rendered.selected .prompt {
    top: 0;
    border-left: 4px solid #57564b;
    border-right: 2px solid #49483e;
}

div.text_cell.unrendered.selected .prompt,
div.text_cell.rendered.selected .prompt {
    top: 0;
    background: #282828;
    border-left: 4px solid #33322b;
    border-right: 2px solid #49483e;
}

div.rendered_html code {
    font-family: monospace, monospace;
    font-size: 11pt;
    padding-top: 3px;
    padding-left: 2px;
    color: #f8f8f0;
    background: #282828;
    background-color: #282828;
}

pre,
code,
kbd,
samp {
    white-space: pre-wrap;
}

.well code,
code {
    font-family: monospace, monospace;
    font-size: 11pt !important;
    line-height: 170% !important;
    color: #f8f8f0;
    background: #282828;
    background-color: #282828;
    border-color: #282828;
}

kbd {
    padding: 1px;
    font-size: 11pt;
    font-weight: 800;
    color: #f8f8f0;
    background-color: transparent !important;
    border: 0;
    box-shadow: none;
}

pre {
    display: block;
    padding: 8.5px;
    margin: 0 0 9px;
    font-size: 12.0pt;
    line-height: 1.42857143;
    color: #f8f8f0;
    background-color: #282828;
    border: 1px solid #282828;
    border-radius: 2px;
}

div.rendered_html {
    color: #f8f8f0;
}

.rendered_html *+ul {
    margin-top: .4em;
    margin-bottom: .3em;
}

.rendered_html *+p {
    margin-top: .5em;
    margin-bottom: .5em;
}

div.rendered_html pre {
    font-family: monospace, monospace;
    font-size: 11pt !important;
    line-height: 170% !important;
    color: #f8f8f0 !important;
    background: #282828;
    background-color: #282828;
    max-width: 80%;
    border-radius: 0px;
    border-left: 3px solid #282828;
    max-width: 80%;
    border-radius: 0px;
    padding-left: 5px;
    margin-left: 6px;
}

div.text_cell_render pre,
div.text_cell_render code {
    font-family: monospace, monospace;
    font-size: 11pt !important;
    line-height: 170% !important;
    color: #f8f8f0;
    background: #1e1e1e;
    background-color: #1e1e1e;
    max-width: 80%;
    border-radius: 0px;
    border-left: none;
}

div.text_cell_render pre {
    border-left: 3px solid #49483e !important;
    max-width: 80%;
    border-radius: 0px;
    padding-left: 5px;
    margin-left: 6px;
}

div.text_cell_render h1,
div.rendered_html h1,
div.text_cell_render h2,
div.rendered_html h2,
div.text_cell_render h3,
div.rendered_html h3,
div.text_cell_render h4,
div.rendered_html h4,
div.text_cell_render h5,
div.rendered_html h5 {
    font-family: sans-serif;
    margin: 0.4em .2em .3em .2em !important;
}

.rendered_html h1:first-child,
.rendered_html h2:first-child,
.rendered_html h3:first-child,
.rendered_html h4:first-child,
.rendered_html h5:first-child,
.rendered_html h6:first-child {
    margin-top: 0.2em !important;
    margin-bottom: 0.2em !important;
}

.rendered_html h1,
.text_cell_render h1 {
    color: #a6e22e !important;
    font-size: 200%;
    text-align: left;
    font-style: normal;
    font-weight: normal;
}

.rendered_html h2,
.text_cell_render h2 {
    color: #a6e22e !important;
    font-size: 170%;
    font-style: normal;
    font-weight: normal;
}

.rendered_html h3,
.text_cell_render h3 {
    color: #a6e22e !important;
    font-size: 140%;
    font-style: normal;
    font-weight: normal;
}

.rendered_html h4,
.text_cell_render h4 {
    color: #a6e22e !important;
    font-size: 110%;
    font-style: normal;
    font-weight: normal;
}

.rendered_html h5,
.text_cell_render h5 {
    color: #a6e22e !important;
    font-size: 100%;
    font-style: normal;
    font-weight: normal;
}

hr {
    margin-top: 8px;
    margin-bottom: 10px;
    border: 0;
    border-top: 1px solid #a6e22e;
}

.rendered_html hr {
    color: #a6e22e;
    background-color: #a6e22e;
    margin-right: 2em;
}

#complete>select>option:hover {
    background: rgba(93, 92, 82, .25);
    background-color: rgba(93, 92, 82, .25);
}

div#_vivaldi-spatnav-focus-indicator._vivaldi-spatnav-focus-indicator {
    position: absolute;
    z-index: 9999999999;
    top: 0px;
    left: 0px;
    box-shadow: none;
    pointer-events: none;
    border-radius: 2px;
}

.rendered_html tr,
.rendered_html th,
.rendered_html td {
    text-align: left;
    vertical-align: middle;
    padding: 0.42em 0.47em;
    line-height: normal;
    white-space: normal;
    max-width: none;
    border: none;
}

.rendered_html td {
    font-family: sans-serif !important;
    font-size: 9.3pt;
}

.rendered_html table {
    font-family: sans-serif !important;
    margin-left: 8px;
    margin-right: auto;
    border: none;
    border-collapse: collapse;
    border-spacing: 0;
    color: #cccccc;
    table-layout: fixed;
}

.rendered_html thead {
    font-family: sans-serif !important;
    font-size: 10.3pt !important;
    background: #1e1e1e;
    color: #cccccc;
    border-bottom: 1px solid #1e1e1e;
    vertical-align: bottom;
}

.rendered_html tbody tr:nth-child(odd) {
    background: #282828;
}

.rendered_html tbody tr {
    background: #202020;
}

.rendered_html tbody tr:hover:nth-child(odd) {
    background: #252525;
}

.rendered_html tbody tr:hover {
    background: #1e1e1e;
}

.rendered_html *+table {
    margin-top: .05em;
}

div.widget-area {
    background-color: #232323;
    background: #232323;
    color: #cccccc;
}

div.widget-area a {
    font-family: sans-serif;
    font-size: 12.0pt;
    font-weight: normal;
    font-style: normal;
    color: #f8f8f0;
    text-shadow: none !important;
}

div.widget-area a:hover,
div.widget-area a:focus {
    font-family: sans-serif;
    font-size: 12.0pt;
    font-weight: normal;
    font-style: normal;
    color: #f8f8f0;
    background: rgba(93, 92, 82, .25);
    background-color: rgba(93, 92, 82, .25);
    border-color: transparent;
    background-image: none;
    text-shadow: none !important;
}

div.widget_item.btn-group>button.btn.btn-default.widget-combo-btn,
div.widget_item.btn-group>button.btn.btn-default.widget-combo-btn:hover {
    background: #2c2c2c;
    background-color: #2c2c2c;
    border: 2px solid #2c2c2c !important;
    font-size: inherit;
    z-index: 0;
}

div.jupyter-widgets.widget-hprogress.widget-hbox {
    display: inline-table !important;
    width: 38% !important;
    margin-left: 10px;
}

div.jupyter-widgets.widget-hprogress.widget-hbox .widget-label,
div.widget-hbox .widget-label,
.widget-hbox .widget-label,
.widget-inline-hbox .widget-label,
div.widget-label {
    text-align: -webkit-auto !important;
    margin-left: 15px !important;
    max-width: 240px !important;
    min-width: 100px !important;
    vertical-align: text-top !important;
    color: #cccccc !important;
    font-size: 14px !important;
}

.widget-hprogress .progress {
    flex-grow: 1;
    height: 20px;
    margin-top: auto;
    margin-left: 12px;
    margin-bottom: auto;
    width: 300px;
}

.progress {
    overflow: hidden;
    height: 22px;
    margin-bottom: 10px;
    padding-left: 10px;
    background-color: #49483e !important;
    border-radius: 2px;
    -webkit-box-shadow: none;
    box-shadow: none;
    z-index: 10;
}

.progress-bar-danger {
    background-color: #e74c3c !important;
}

.progress-bar-info {
    background-color: #3498db !important;
}

.progress-bar-warning {
    background-color: #ff914d !important;
}

.progress-bar-success {
    background-color: #83a83b !important;
}

.widget-select select {
    margin-left: 12px;
}

.rendered_html :link {
    font-family: sans-serif;
    font-size: 100%;
    color: #a6e22e;
    text-decoration: underline;
}

.rendered_html :visited,
.rendered_html :visited:active,
.rendered_html :visited:focus {
    color: #acdf45;
}

.rendered_html :visited:hover,
.rendered_html :link:hover {
    font-family: sans-serif;
    font-size: 100%;
    color: #97dc0b;
}

div.cell.text_cell a.anchor-link:link {
    font-size: inherit;
    text-decoration: none;
    padding: 0px 20px;
    visibility: none;
    color: rgba(0, 0, 0, .32);
}

div.cell.text_cell a.anchor-link:link:hover {
    font-size: inherit;
    color: #a6e22e;
}

.navbar-text {
    margin-top: 4px;
    margin-bottom: 0px;
}

#clusters>a {
    color: #a6e22e;
    text-decoration: underline;
    cursor: auto;
}

#clusters>a:hover {
    color: #ae81ff;
    text-decoration: underline;
    cursor: auto;
}

#nbextensions-configurator-container>div.row.container-fluid.nbext-selector>h3 {
    font-size: 17px;
    margin-top: 5px;
    margin-bottom: 8px;
    height: 24px;
    padding: 4px 0 4px 0;
}

div#nbextensions-configurator-container.container,
#nbextensions-configurator-container.container {
    width: 100%;
    margin-right: auto;
    margin-left: auto;
}

div.nbext-selector>nav>.nav>li>a {
    font-family: sans-serif;
    font-size: 10.5pt;
    padding: 2px 5px;
}

div.nbext-selector>nav>.nav>li>a:hover {
    background: transparent;
}

div.nbext-selector>nav>.nav>li:hover {
    background-color: rgba(93, 92, 82, .25) !important;
    background: rgba(93, 92, 82, .25) !important;
}

div.nbext-selector>nav>.nav>li.active:hover {
    background: transparent !important;
    background-color: transparent !important;
}

.nav-pills>li.active>a,
.nav-pills>li.active>a:active,
.nav-pills>li.active>a:hover,
.nav-pills>li.active>a:focus {
    color: #f8f8f2;
    background-color: rgba(93, 92, 82, .25) !important;
    background: rgba(93, 92, 82, .25) !important;
    -webkit-backface-visibility: hidden;
    -webkit-font-smoothing: subpixel-antialiased !important;
}

div.nbext-readme>.nbext-readme-contents>.rendered_html {
    font-family: sans-serif;
    font-size: 11.5pt;
    line-height: 145%;
    padding: 1em 1em;
    color: #f8f8f0;
    background-color: #282828;
    -webkit-box-shadow: none;
    -moz-box-shadow: none;
    box-shadow: none;
}

.nbext-icon,
.nbext-desc,
.nbext-compat-div,
.nbext-enable-btns,
.nbext-params {
    margin-bottom: 8px;
    font-size: 11.5pt;
}

div.nbext-readme>.nbext-readme-contents {
    padding: 0;
    overflow-y: hidden;
}

div.nbext-readme>.nbext-readme-contents:not(:empty) {
    margin-top: 0.5em;
    margin-bottom: 2em;
    border: none;
    border-top-color: rgba(148, 204, 114, .2);
}

.nbext-showhide-incompat {
    padding-bottom: 0.5em;
    color: #888888;
    font-size: 10.5pt;
}

.nbext-filter-menu.dropdown-menu>li>a:hover,
.nbext-filter-menu.dropdown-menu>li>a:focus,
.nbext-filter-menu.dropdown-menu>li>a.ui-state-focus {
    color: #f8f8f0 !important;
    background-color: rgba(93, 92, 82, .25) !important;
    background: rgba(93, 92, 82, .25) !important;
    border-color: rgba(93, 92, 82, .25) !important;
}

.nbext-filter-input-wrap>.nbext-filter-input-subwrap,
.nbext-filter-input-wrap>.nbext-filter-input-subwrap>input {
    border: none;
    outline: none;
    background-color: transparent;
    padding: 0;
    vertical-align: middle;
    margin-top: -2px;
}

span.rendered_html code {
    background-color: transparent;
    color: #f8f8f0;
}

#nbextensions-configurator-container>div.row.container-fluid.nbext-selector {
    padding-left: 0px;
    padding-right: 0px;
}

.nbext-filter-menu {
    max-height: 55vh !important;
    overflow-y: auto;
    outline: none;
    border: none;
}

.nbext-filter-menu:hover {
    border: none;
}

.alert-warning {
    background-color: #232323;
    border-color: #232323;
    color: #f8f8f0;
}

.notification_widget.danger {
    color: #ffffff;
    background-color: #e74c3c;
    border-color: #e74c3c;
    padding-right: 5px;
}

#nbextensions-configurator-container>div.nbext-buttons.tree-buttons.no-padding.pull-right>span>button {
    border: none !important;
}

button#refresh_running_list {
    border: none !important;
}

mark,
.mark {
    background-color: #282828;
    color: #f8f8f0;
    padding: .15em;
}

a.text-warning,
a.text-warning:hover {
    color: #75715e;
}

a.text-warning.bg-warning {
    background-color: #1e1e1e;
}

span.bg-success.text-success {
    background-color: transparent;
    color: #a6e22e;
}

span.bg-danger.text-danger {
    background-color: #1e1e1e;
    color: #f92672;
}

.has-success .input-group-addon {
    color: #a6e22e;
    border-color: transparent;
    background: inherit;
    background-color: rgba(83, 180, 115, .10);
}

.has-success .form-control {
    border-color: #a6e22e;
    -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.025);
    box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.025);
}

.has-error .input-group-addon {
    color: #f92672;
    border-color: transparent;
    background: inherit;
    background-color: rgba(192, 57, 67, .10);
}

.has-error .form-control {
    border-color: #f92672;
    -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.025);
    box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.025);
}

.kse-input-group-pretty>kbd {
    font-family: monospace, monospace;
    color: #f8f8f0;
    font-weight: normal;
    background: transparent;
}

.kse-input-group-pretty>kbd {
    font-family: monospace, monospace;
    color: #f8f8f0;
    font-weight: normal;
    background: transparent;
}

div.nbext-enable-btns .btn[disabled],
div.nbext-enable-btns .btn[disabled]:hover,
.btn-default.disabled,
.btn-default[disabled] {
    background: #2c2c2c;
    background-color: #2c2c2c;
    color: #f3f3e6;
}

label#Keyword-Filter {
    display: none;
}

.input-group .nbext-list-btn-add,
.input-group-btn:last-child>.btn-group>.btn {
    background: #2f2f2f;
    background-color: #2f2f2f;
    border-color: #2f2f2f;
    border: 2px solid #2f2f2f;
}

.input-group .nbext-list-btn-add:hover,
.input-group-btn:last-child>.btn-group>.btn:hover {
    background: #2a2a2a;
    background-color: #2a2a2a;
    border-color: #2a2a2a;
    border: 2px solid #2a2a2a;
}

#notebook-container>div.cell.code_cell.rendered.selected>div.widget-area>div.widget-subarea>div>div.widget_item.btn-group>button.btn.btn-default.dropdown-toggle.widget-combo-carrot-btn {
    background: #2f2f2f;
    background-color: #2f2f2f;
    border-color: #2f2f2f;
}

#notebook-container>div.cell.code_cell.rendered.selected>div.widget-area>div.widget-subarea>div>div.widget_item.btn-group>button.btn.btn-default.dropdown-toggle.widget-combo-carrot-btn:hover {
    background: #2a2a2a;
    background-color: #2a2a2a;
    border-color: #2a2a2a;
}

.ui-widget-content {
    background: #2f2f2f;
    background-color: #2f2f2f;
    border: 2px solid #2f2f2f;
    color: #f8f8f0;
}

div.collapsible_headings_toggle {
    color: rgba(93, 92, 82, .5) !important;
}

div.collapsible_headings_toggle:hover {
    color: #a6e22e !important;
}

.collapsible_headings_toggle .h1,
.collapsible_headings_toggle .h2,
.collapsible_headings_toggle .h3,
.collapsible_headings_toggle .h4,
.collapsible_headings_toggle .h5,
.collapsible_headings_toggle .h6 {
    margin: 0.3em .4em 0em 0em !important;
    line-height: 1.2 !important;
}

div.collapsible_headings_toggle .fa-caret-down:before,
div.collapsible_headings_toggle .fa-caret-right:before {
    font-size: xx-large;
    transition: transform 1000ms;
    transform: none !important;
}

.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h1:after,
.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h2:after,
.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h3:after,
.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h4:after,
.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h5:after,
.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h6:after {
    position: absolute;
    right: 0;
    bottom: 20% !important;
    content: "[\002026]";
    color: rgba(93, 92, 82, .5) !important;
    padding: 0.5em 0em 0em 0em !important;
}

.collapsible_headings_ellipsis .rendered_html h1,
.collapsible_headings_ellipsis .rendered_html h2,
.collapsible_headings_ellipsis .rendered_html h3,
.collapsible_headings_ellipsis .rendered_html h4,
.collapsible_headings_ellipsis .rendered_html h5,
.collapsible_headings_ellipsis .rendered_html h6,
.collapsible_headings_toggle .fa {
    transition: transform 1000ms !important;
    -webkit-transform: inherit !important;
    -moz-transform: inherit !important;
    -ms-transform: inherit !important;
    -o-transform: inherit !important;
    transform: inherit !important;
    padding-right: 0px !important;
}

#toc-wrapper {
    z-index: 90;
    position: fixed !important;
    display: flex;
    flex-direction: column;
    overflow: hidden;
    padding: 10px;
    border-style: solid;
    border-width: thin;
    border-right-width: medium !important;
    background-color: #1e1e1e !important;
}

#toc-wrapper.ui-draggable.ui-resizable.sidebar-wrapper {
    border-color: rgba(93, 92, 82, .25) !important;
}

#toc a,
#navigate_menu a,
.toc {
    color: #f8f8f0 !important;
    font-size: 11pt !important;
}

#toc li>span:hover {
    background-color: rgba(93, 92, 82, .25) !important;
}

#toc a:hover,
#navigate_menu a:hover,
.toc {
    color: #f8f8f2 !important;
    font-size: 11pt !important;
}

#toc-wrapper .toc-item-num {
    color: #a6e22e !important;
    font-size: 11pt !important;
}

input.raw_input {
    font-family: monospace, monospace;
    font-size: 11pt !important;
    color: #f8f8f0;
    background-color: #282828;
    border-color: #252525;
    background: #252525;
    width: auto;
    vertical-align: baseline;
    padding: 0em 0.25em;
    margin: 0em 0.25em;
    -webkit-box-shadow: none;
    box-shadow: none;
}

audio,
video {
    display: inline;
    vertical-align: middle;
    align-content: center;
    margin-left: 20%;
}

.cmd-palette .modal-body {
    padding: 0px;
    margin: 0px;
}

.cmd-palette form {
    background: #293547;
    background-color: #293547;
}

.typeahead-field input:last-child,
.typeahead-hint {
    background: #293547;
    background-color: #293547;
    z-index: 1;
}

.typeahead-field input {
    font-family: sans-serif;
    color: #f8f8f0;
    border: none;
    font-size: 28pt;
    display: inline-block;
    line-height: inherit;
    padding: 3px 10px;
    height: 70px;
}

.typeahead-select {
    background-color: #293547;
}

body>div.modal.cmd-palette.typeahead-field {
    display: table;
    border-collapse: separate;
    background-color: #2b3850;
}

.typeahead-container button {
    font-family: sans-serif;
    font-size: 28pt;
    background-color: #2f2f2f;
    border: none;
    display: inline-block;
    line-height: inherit;
    padding: 3px 10px;
    height: 70px;
}

.typeahead-search-icon {
    min-width: 40px;
    min-height: 55px;
    display: block;
    vertical-align: middle;
    text-align: center;
}

.typeahead-container button:focus,
.typeahead-container button:hover {
    color: #f8f8f0;
    background-color: #2a2a2a;
    border-color: #2a2a2a;
}

.typeahead-list>li.typeahead-group.active>a,
.typeahead-list>li.typeahead-group>a,
.typeahead-list>li.typeahead-group>a:focus,
.typeahead-list>li.typeahead-group>a:hover {
    display: none;
}

.typeahead-dropdown>li>a,
.typeahead-list>li>a {
    color: #f8f8f0;
    text-decoration: none;
}

.typeahead-dropdown,
.typeahead-list {
    font-family: sans-serif;
    font-size: 9pt;
    color: #f8f8f0;
    background-color: #202937;
    border: none;
    background-clip: padding-box;
    margin-top: 0px;
    padding: 3px 2px 3px 0px;
    line-height: 1.7;
}

.typeahead-dropdown>li.active>a,
.typeahead-dropdown>li>a:focus,
.typeahead-dropdown>li>a:hover,
.typeahead-list>li.active>a,
.typeahead-list>li>a:focus,
.typeahead-list>li>a:hover {
    color: #f8f8f0;
    background-color: #2b3850;
    border-color: #2b3850;
}

.command-shortcut:before {
    content: "(command)";
    padding-right: 3px;
    color: #75715e;
}

.edit-shortcut:before {
    content: "(edit)";
    padding-right: 3px;
    color: #75715e;
}

ul.typeahead-list i {
    margin-left: 1px;
    width: 18px;
    margin-right: 10px;
}

ul.typeahead-list {
    max-height: 50vh;
    overflow: auto;
}

.typeahead-list>li {
    position: relative;
    border: none;
}

div.input.typeahead-hint,
input.typeahead-hint,
body>div.modal.cmd-palette.in>div>div>div>form>div>div.typeahead-field>span.typeahead-query>input.typeahead-hint {
    color: #75715e !important;
    background-color: transparent;
    padding: 3px 10px;
}

.typeahead-dropdown>li>a,
.typeahead-list>li>a {
    display: block;
    padding: 5px;
    clear: both;
    font-weight: 400;
    line-height: 1.7;
    border: 1px solid #202937;
    border-bottom-color: rgba(93, 92, 82, .5);
}

body>div.modal.cmd-palette.in>div {
    min-width: 750px;
    margin: 150px auto;
}

.typeahead-container strong {
    font-weight: bolder;
    color: #a6e22e;
}

#find-and-replace #replace-preview .match,
#find-and-replace #replace-preview .insert {
    color: #ffffff;
    background-color: #57564b;
    border-color: #57564b;
    border-style: solid;
    border-width: 1px;
    border-radius: 0px;
}

#find-and-replace #replace-preview .replace .match {
    background-color: #f92672;
    border-color: #f92672;
    border-radius: 0px;
}

#find-and-replace #replace-preview .replace .insert {
    background-color: #a6e22e;
    border-color: #a6e22e;
    border-radius: 0px;
}

.jupyter-dashboard-menu-item.selected::before {
    font-family: 'FontAwesome' !important;
    content: '\f00c' !important;
    position: absolute !important;
    color: #a6e22e !important;
    left: 0px !important;
    top: 13px !important;
    font-size: 12px !important;
}

.shortcut_key,
span.shortcut_key {
    display: inline-block;
    width: 16ex;
    text-align: right;
    font-family: monospace;
}

.jupyter-keybindings {
    padding: 1px;
    line-height: 24px;
    border-bottom: 1px solid rgba(93, 92, 82, .25);
}

.jupyter-keybindings i {
    background: #282828;
    font-size: small;
    padding: 5px;
    margin-left: 7px;
}

div#short-key-bindings-intro.well,
.well {
    background-color: #2f2f2f;
    border: 1px solid #2f2f2f;
    color: #f8f8f0;
    border-radius: 2px;
    -webkit-box-shadow: none;
    box-shadow: none;
}

#texteditor-backdrop {
    background: #1e1e1e;
    background-color: #1e1e1e;
}

#texteditor-backdrop #texteditor-container .CodeMirror-gutter,
#texteditor-backdrop #texteditor-container .CodeMirror-gutters {
    background: #49483e;
    background-color: #49483e;
    color: #75715e;
}

.edit_app #menubar .navbar {
    margin-bottom: 0px;
}

#texteditor-backdrop #texteditor-container {
    padding: 0px;
    background-color: #282828;
    box-shadow: none;
}

.terminal-app {
    background: #1e1e1e;
}

.terminal-app>#header {
    background: #1e1e1e;
}

.terminal-app .terminal {
    font-family: monospace, monospace;
    font-size: 11pt;
    line-height: 170%;
    color: #f8f8f0;
    background: #282828;
    padding: 0.4em;
    border-radius: 2px;
    -webkit-box-shadow: none;
    box-shadow: none;
}

.terminal .xterm-viewport {
    background-color: #282828;
    color: #f8f8f0;
    overflow-y: auto;
}

.terminal .xterm-color-0 {
    color: #a6e22e;
}

.terminal .xterm-color-1 {
    color: #a6e22e;
}

.terminal .xterm-color-2 {
    color: #f92672;
}

.terminal .xterm-color-3 {
    color: #a6e22e;
}

.terminal .xterm-color-4 {
    color: #ae81ff;
}

.terminal .xterm-color-5 {
    color: #e6db74;
}

.terminal .xterm-color-6 {
    color: #a6e22e;
}

.terminal .xterm-color-7 {
    color: #a6e22e;
}

.terminal .xterm-color-8 {
    color: #a6e22e;
}

.terminal .xterm-color-9 {
    color: #e6db74;
}

.terminal .xterm-color-10 {
    color: #a6e22e;
}

.terminal .xterm-color-14 {
    color: #a6e22e;
}

.terminal .xterm-bg-color-15 {
    background-color: #282828;
}

.terminal:not(.xterm-cursor-style-underline):not(.xterm-cursor-style-bar) .terminal-cursor {
    background-color: #a6e22e;
    color: #282828;
}

.terminal:not(.focus) .terminal-cursor {
    outline: 1px solid #a6e22e;
    outline-offset: -1px;
}

.celltoolbar {
    font-size: 100%;
    padding-top: 3px;
    border-color: transparent;
    border-bottom: thin solid rgba(148, 204, 114, .2);
    background: transparent;
}

.cell-tag,
.tags-input input,
.tags-input button {
    color: #f8f8f0;
    background-color: #1e1e1e;
    background-image: none;
    border: 1px solid #f8f8f0;
    border-radius: 1px;
    box-shadow: none;
    width: inherit;
    font-size: inherit;
    height: 22px;
    line-height: 22px;
}

#notebook-container>div.cell.code_cell.rendered.selected>div.input>div.inner_cell>div.ctb_hideshow.ctb_show>div>div>button,
#notebook-container>div.input>div.inner_cell>div.ctb_hideshow.ctb_show>div>div>button {
    font-size: 10pt;
    color: #f8f8f0;
    background-color: #1e1e1e;
    background-image: none;
    border: 1px solid #f8f8f0;
    border-radius: 1px;
    box-shadow: none;
    width: inherit;
    font-size: inherit;
    height: 22px;
    line-height: 22px;
}

div#pager #pager-contents {
    background: #1e1e1e !important;
    background-color: #1e1e1e !important;
}

div#pager pre {
    color: #f8f8f0 !important;
    background: #282828 !important;
    background-color: #282828 !important;
    padding: 0.4em;
}

div#pager .ui-resizable-handle {
    top: 0px;
    height: 8px;
    background: #a6e22e !important;
    border-top: 1px solid #a6e22e;
    border-bottom: 1px solid #a6e22e;
}

div.CodeMirror,
div.CodeMirror pre {
    font-family: monospace, monospace;
    font-size: 11pt;
    line-height: 170%;
    color: #f8f8f0;
}

div.CodeMirror-lines {
    padding-bottom: .9em;
    padding-left: .5em;
    padding-right: 1.5em;
    padding-top: .7em;
}

span.ansiblack,
.ansi-black-fg {
    color: #282828;
}

span.ansiblue,
.ansi-blue-fg,
.ansi-blue-intense-fg {
    color: #66d9ef;
}

span.ansigray,
.ansi-gray-fg,
.ansi-gray-intense-fg {
    color: #888888;
}

span.ansigreen,
.ansi-green-fg {
    color: #a6e22e;
}

.ansi-green-intense-fg {
    color: #888888;
}

span.ansipurple,
.ansi-purple-fg,
.ansi-purple-intense-fg {
    color: #ae81ff;
}

span.ansicyan,
.ansi-cyan-fg,
.ansi-cyan-intense-fg {
    color: #ae81ff;
}

span.ansiyellow,
.ansi-yellow-fg,
.ansi-yellow-intense-fg {
    color: #e6db74;
}

span.ansired,
.ansi-red-fg,
.ansi-red-intense-fg {
    color: #f92672;
}

div.output-stderr {
    background-color: #f92672;
}

div.output-stderr pre {
    color: #f8f8f2;
}

div.js-error {
    color: #f92672;
}

.ipython_tooltip {
    font-family: monospace, monospace;
    font-size: 11pt;
    line-height: 170%;
    border: 2px solid #141414;
    background: #282828;
    background-color: #282828;
    border-radius: 2px;
    overflow-x: visible;
    overflow-y: visible;
    box-shadow: none;
    position: absolute;
    z-index: 1000;
}

.ipython_tooltip .tooltiptext pre {
    font-family: monospace, monospace;
    font-size: 11pt;
    line-height: 170%;
    background: #282828;
    background-color: #282828;
    color: #f8f8f0;
    overflow-x: visible;
    overflow-y: visible;
    max-width: 900px;
}

div#tooltip.ipython_tooltip {
    overflow-x: wrap;
    overflow-y: visible;
    max-width: 800px;
}

div.tooltiptext.bigtooltip {
    overflow-x: visible;
    overflow-y: scroll;
    height: 400px;
    max-width: 800px;
}

.cm-s-ipython.CodeMirror {
    font-family: monospace, monospace;
    font-size: 9pt;
    background: #282828;
    color: #f8f8f0;
    border-radius: 2px;
    font-style: normal;
    font-weight: normal;
}

.cm-s-ipython div.CodeMirror-selected {
    background: #49483e;
}

.CodeMirror-gutters {
    border: none;
    border-right: 1px solid #49483e !important;
    background-color: #49483e !important;
    background: #49483e !important;
    border-radius: 0px;
    white-space: nowrap;
}

.cm-s-ipython .CodeMirror-gutters {
    background: #282828 !important;
    border: none;
    border-radius: 0px;
    width: 36px;
}

.cm-s-ipython .CodeMirror-linenumber {
    color: #75715e;
}

.CodeMirror-sizer {
    margin-left: 40px;
}

.CodeMirror-linenumber,
div.CodeMirror-linenumber,
.CodeMirror-gutter.CodeMirror-linenumberdiv.CodeMirror-gutter.CodeMirror-linenumber {
    padding-right: 1px;
    margin-left: 0px;
    margin: 0px;
    width: 26px !important;
    padding: 0px;
    text-align: right;
}

.CodeMirror-linenumber {
    color: #75715e;
    left: 0px !important;
}

.cm-s-ipython .CodeMirror-cursor {
    border-left: 2px solid #0095ff !important;
}

.cm-s-ipython span.cm-comment {
    color: #75715e;
    font-style: italic;
}

.cm-s-ipython span.cm-atom {
    color: #ae81ff;
}

.cm-s-ipython span.cm-number {
    color: #ae81ff;
}

.cm-s-ipython span.cm-property {
    color: #f8f8f0;
}

.cm-s-ipython span.cm-attribute {
    color: #f8f8f0;
}

.cm-s-ipython span.cm-keyword {
    color: #f92672;
    font-weight: normal;
}

.cm-s-ipython span.cm-string {
    color: #e6db74;
}

.cm-s-ipython span.cm-meta {
    color: #fd971f;
}

.cm-s-ipython span.cm-operator {
    color: #a6e22e;
}

.cm-s-ipython span.cm-builtin {
    color: #a6e22e;
}

.cm-s-ipython span.cm-variable {
    color: #f8f8f0;
}

.cm-s-ipython span.cm-variable-2 {
    color: #a6e22e;
}

.cm-s-ipython span.cm-variable-3 {
    color: #fd971f;
}

.cm-s-ipython span.cm-def {
    color: #a6e22e;
    font-weight: normal;
}

.cm-s-ipython span.cm-error {
    background: rgba(249, 38, 114, .4);
}

.cm-s-ipython span.cm-tag {
    color: #ae81ff;
}

.cm-s-ipython span.cm-link {
    color: #a6e22e;
}

.cm-s-ipython span.cm-storage {
    color: #ae81ff;
}

.cm-s-ipython span.cm-entity {
    color: #a6e22e;
}

.cm-s-ipython span.cm-quote {
    color: #e6db74;
}

div.CodeMirror span.CodeMirror-matchingbracket {
    color: #ffffff;
    font-weight: bold;
    background-color: #49483e;
}

div.CodeMirror span.CodeMirror-nonmatchingbracket {
    color: #ffffff;
    font-weight: bold;
    background: rgba(249, 38, 114, .4) !important;
}

.cm-header-1 {
    font-size: 215%;
}

.cm-header-2 {
    font-size: 180%;
}

.cm-header-3 {
    font-size: 150%;
}

.cm-header-4 {
    font-size: 120%;
}

.cm-header-5 {
    font-size: 100%;
}

.cm-s-default .cm-hr {
    color: #a6e22e;
}

div.cell.text_cell .cm-s-default .cm-header {
    font-family: sans-serif;
    font-weight: normal;
    color: #a6e22e !important;
    margin-top: 0.3em !important;
    margin-bottom: 0.3em !important;
}

div.cell.text_cell .cm-s-default span.cm-variable-2 {
    color: #f8f8f0 !important;
}

div.cell.text_cell .cm-s-default span.cm-variable-3 {
    color: #fd971f !important;
}

.cm-s-default span.cm-comment {
    color: #75715e !important;
}

.cm-s-default .cm-tag {
    color: #529b2f;
}

.cm-s-default .cm-builtin {
    color: #a6e22e;
}

.cm-s-default .cm-string {
    color: #e6db74;
}

.cm-s-default .cm-keyword {
    color: #f92672;
}

.cm-s-default .cm-number {
    color: #ae81ff;
}

.cm-s-default .cm-error {
    color: #ae81ff;
}

.cm-s-default .cm-link {
    color: #a6e22e;
}

.cm-s-default .cm-atom {
    color: #ae81ff;
}

.cm-s-default .cm-def {
    color: #a6e22e;
}

.CodeMirror-cursor {
    border-left: 2px solid #0095ff !important;
    border-right: none;
    width: 0;
}

.cm-s-default div.CodeMirror-selected {
    background: #49483e;
}

.cm-s-default .cm-selected {
    background: #49483e;
}

.MathJax_Display,
.MathJax {
    border: 0 !important;
    font-size: 100% !important;
    text-align: center !important;
    margin: 0em !important;
    line-height: 2.25 !important;
}

.MathJax:focus,
body :focus .MathJax {
    display: inline-block !important;
}

.MathJax:focus,
body :focus .MathJax {
    display: inline-block !important;
}

.completions {
    position: absolute;
    z-index: 110;
    overflow: hidden;
    border: medium solid #49483e;
    box-shadow: none;
    line-height: 1;
}

.completions select {
    background: #282828;
    background-color: #282828;
    outline: none;
    border: none;
    padding: 0px;
    margin: 0px;
    margin-left: 2px;
    overflow: auto;
    font-family: monospace, monospace;
    font-size: 11pt;
    color: #f8f8f0;
    width: auto;
}

/* div#maintoolbar {
    display: none !important;
}

#header-container {
    display: none !important;
} */

<script>MathJax.Hub.Config( {
        "HTML-CSS": {

            /*preferredFont: "TeX",*/
            /*availableFonts: ["TeX", "STIX"],*/
            styles: {

                scale: 100,
                ".MathJax_Display": {
                    "font-size": "100%",
                }
            }
        }
    }

);
</script>

There is another way too:

Refer this for more: jupyter-themes

Things to do now:

• Install jupyter themes : pip install jupyterthemes

• Simply use it by: jt [commands]

My favorite one is:

jt -t grade3 -T -N -fs 9 -nfs 9 -tfs 9 -cellw 1200

Here, -t means use grade3 theme, -T stands for Toolbars on, -N stands for Notebook name on, -fs means use font size 9, -nfs means use notebook font size 9, -tfs means use toolbar font size 9 and finally -cellw means use 1200 as the width for the notebook workspace.

You might want to check out the original repository mentioned in the link above to try out different themes and others interesting stuffs.

Event-driven means that the server only reacts when an event occurs. This allow us to create high performance, highly scalable, “real-time” application. Non-blocking I/O model means that you can run your I/O request asynchronously without blocking your application. In this programming model open/read/write/update operation on devices and resources managed by the file-system don’t block the calling thread. For e.g. A real time chat app, interactive games can be created with very high performance using NODE.

My thoughts :

My feeling is that Node.js is especially suited for applications where you’d like to maintain a persistent connection from the browser back to the server. Doing heavy load on many of the web’s giants, like Ruby on Rails (Ruby Framework) or Django (Python Framework), would create immense load on the server, because each active client eats up one server process but NODE handles this in a different, better way. It’s worth mentioning that Ruby and Python both have tools to do this sort of thing (event machine and twisted, respectively), but that Node.js does it exceptionally well, and from the ground up.

It’s also worth pointing out that Node.js is also great for situations in which you’ll be reusing a lot of code across the client/server gap. The Express framework makes this really easy, and a lot of developers, including me, are suggesting this might be the future of web development.

All I can say from my experience that it’s a whole lot of fun to write code in NODE, and a big part of this is spending less time thinking about how you’re going to plan certain logic. It runs Javascript, so you can use the same language on server and client, and even share some code between them.

Just a fact :

Companies like NetFlix, PayPal, LinkedIn, Walmart, Uber, Ebay, NASA, Google, Yahoo, Mozilla, Github, Microsoft, New York Times, Wall street journal, GoDaddy and many others use NODEJS in production.

The Fun Part :

So why should one be using NODE? Let’s point out the obvious.

• One of the great thing about NODEJS is, it’s everywhere. Yes, you hear that right. EVERYWHERE! You can write web applications, desktop applications, mobile applications, cloud services, Internet Of Things projects, APIs and many more using NODE.

• Open Source: NODEJS is an open source platform, which means it is easily accessible and maintained by the best developers around the world. It’s source code is easily available. It is secure, flexible and free.

• The ever-growing NPM packages: Being an open-source technology, NodeJS has a shared repository of good-to-go tools and modules. The number of modules in the Node Package Manager (NPM) has increased at a exponential pace, overtaking the RoR (Ruby on Rails) gems and PHP bundles. At over 350,000 packages, the npm registry contains more than double the next most populated package registry (which is the Apache Maven repository). In fact, it is currently the largest package registry in the world. In the preceding four weeks, users installed 18 billion packages. Daily 500 packages are uploaded to the npm community. This simply means that you will find what you are searching for.

• Cross Platform: Node.js is cross-platform means it works on Windows, OSX and Linux. A large number of the Node.js community write Node.js on OSX and then deploy to Linux servers. Applications made from NODEJS also can run on both iOS and android.

• Lightweight and Extensible: Node.js is based on JavaScript which can be executed on client side as well as server side. Also, it supports exchange of data using JSON which is easily consumed by JavaScript. This makes it light weight as compared to other frameworks. Node.js is open source. Hence you can extend it as per your needs.

• Easy to Learn: According to Node.js’s 2016 User Survey Javascript is one of the most popular programming languages for front-end development. Nearly every front-end developer is familiar with this universal language. Therefore, it is much easier for them to switch to using Node.js at the back-end. It requires less effort and less time to learn and work with, even for a junior Javascript programmer.

Personally, I love JavaScript and its weirdness. So these were my small thoughts on why one should consider NODEJS. If you are already using or familiar with NODE then leave your thoughts in the comment below and why you use NODE. I would love to read your answers.

What’s BAD? Hacker even started selling ransomware-as-a-service (RaaS) kits in an attempt to spread this creepy threat more easily, so that even a non-tech user can create their own ransomware and distribute the threat to a wider audience.

The WORSE — You could see a massive increase in the number of ransomware campaigns during the next several months, thanks to new Android apps available for anyone to download that let them quickly and easily create Android ransomware with their own devices.

Security researchers at Antivirus firm Symantec have spotted some Android apps available on hacking forums and through advertisements on a social networking messaging service popular in China, which let any wannabe hacker download and use Trojan Development Kits (TDKs).

How to Create Your Own Android Ransomware?

With an easy-to-use interface, these apps are no different from any other Android app apart from the fact that it allows users to create their custom mobile malware with little to no programming knowledge. You do not need to be a computer specialist or a good programmer to do this.

To create customized ransomware, users can download one such app (for security reasons links are not shared), install and open it, where it offers to choose from the following options, which are displayed on the app’s on-screen for.

The message that is to be shown on the locked screen of the infected device

• The key to be used to unlock that infected device

• The icon to be used by their malware

• Custom mathematical operations to randomize the code

• Type of animation to be displayed on the infected device

Once all of the information has been filled in, users just require hitting the “Create” button.

If the user hasn’t been created before, the app will prompt him/her to subscribe to the service before proceeding. The app allows the user to start an online chat with its developer where he/she can arrange a one-time payment.

After the payment has been made, the “malware is created and stored in the external storage in ready-to-ship condition.” and then the user can continue with the process, making as many as victims as the user can.

“Anyone unlucky enough to be tricked into installing the malware will end up with a locked device held to ransom.” researchers say.

“The malware created using this automation process follows the typical Lockdroid behavior of locking the device’s screen with a SYSTEM_ALERT_WINDOW and displaying a text field for the victim to enter the unlock code.”

The Lockdroid ransomware has the ability to lock the infected device, change the device PIN, and delete all of its user data through a factory reset, and even prevent the user from uninstalling the malware.

Such apps allow anyone interested in hacking and criminal activities to develop a ready-to-use piece of ransomware malware just by using their smartphones without any need to write a single line of code or without any programming and computer skills.

“However, these apps are not just useful for aspiring and inexperienced cyber criminals as even hardened malware authors could find these easy-to-use kits an efficient alternative to putting the work in themselves,” the researchers say.

So, get ready to expect an increase in mobile ransomware variants in coming months.

How to Protect Your Android Devices from Ransomware Attacks?

In order to protect against such threats on mobile devices, you are recommended to:

• Always keep regular backups of your important data.

• Make sure that you run an active anti-virus security suite of tools on your machine.

• Avoid downloading apps from unknown sites and third-party app stores.

• Always pay close attention to the permissions requested by an app, even if it is downloaded from an official app store.

• Do not open any email attachments from unknown sources.

• Finally, browse the Internet safely.

To make this happen follow the instruction:

• Open any text editor and paste the code below and save it as “name.vbs”. Remember that the extension must be “.vbs” but the filename can be anything you want.

• Copy the below given code into the file you just created.

  Set Sapi = Wscript.CreateObject("SAPI.SpVoice")

  dim str

  if hour(time) < 12 then

  Sapi.speak "Good Morning , Nice to see you. "

  else

  if hour(time) > 12 then

  if hour(time) > 16 then

  Sapi.speak "Good evening, Nice to see you."

  else

  Sapi.speak "Good afternoon, Nice to see you."

  end if

  end if

  end if

• Goto C:\Users<your username>\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\ and paste the above made “name.vbs” file here.

Now everytime you turn your computer on, it will greet you with different messsages according to the time.

Feel free to modify the code and configure this accordingly.

It was announced on April 29, 2015 by Microsoft at the 2015 Build conference. On April 14, 2016, it was released to public. The source code is available here on GitHub.

So why do I love this text editor? Simple answer would be “Coz it’s awesomme.” Let’s see some cool features :

• The UI/UX is amazing. You have to try this for yourself to see it. I’m confident you will love it. If you want to customize further on then you are provided with hundreds of themes in Extension tab.

  Here is a sample screenshot.

• It falls on the sweet spot between simple light code editor and a IDE. It’s fast, light and has features like Always-On IntelliSense, Side-by-Side Editing, Huge Language Support and blah blah blah!

• I’m a huge fan of Integrated Version Control feature. This is very handy for staging, commiting and reverting.

• Another cool thing is that it has Integrated Terminal which opens up many terminal windows on the bottom of the screen. You can toggle this by Ctrl + `.

• There is another great feature called Peek which is toggled by Shift + F12. While coding, you may often forget a particular function, where the function is initially defined, and what are the required parameters. With Peek, you can select a function then hit Shift + F12. The selection expands into an inline window showing the complete definition of the function as well as where the function is defined. The feature currently works in C, C#, JavaScript, TypeScript, .NET, and a few other programming languages.

• Rename All Occurrences . Refactoring is a necessary aspect of writing and maintaining clean code, but it can be quite the headache — especially when you’re refactoring a large module or an otherwise huge chunk of code. So instead of hunting through dozens of files just to rename a variable or method, let VS Code do it for you. If you select a variable/method and hit F2, you can edit the name and it will change every instance of that variable’s name throughout the entire current working project. If you only want to change within the current file, use the Command + F2 (on Mac) or Ctrl + F2 (on Windows) keyboard shortcut and VS Code will spawn a cursor at every instance throughout the current file.

• Live Share. VS Code Live Share is a brand new feature that is still just in developer preview. It allows you to share your workspace in realtime, live editing, pin to the user to follow their cursor, group debugging and many more. It’s really helpful if you work remotely or when you need to collaborate with someone who isn’t around.

• Edit Multiple Lines at Once. If you ever need to insert or delete multiple instances of text throughout a document, all you have to do is create multiple cursors. You can do this by holding down Option (on Mac) or Alt (on Windows) and clicking anywhere in the text. Every click creates a new cursor. This is particularly useful for things like HTML, where you might want to add many instances of the same class or change the format of several hyperlinks.

• Extensions are editor’s best friend. VS Code has a market full of these which can help you get coding easily. here is the link for the market if interested. Some must have for me are :

  1. Emmet

  2. Beautify

  3. To Do Task

  4. For JavaScript Developers : QuokkaJS

  5. A clean dark theme : One Dark Pro

Note : Before VS Code I used Sublime text and Atom. Both were kinda nice but it wasn’t the best for me. VS Code is where I am settled for now. It’s fast and comfortable to use. I can’t think of any other reason why I should be switching. “Good work Microsoft, you guys nailed it” , I’d say.

These are some cool things I like about VS Code. Feel free to shoot me a mail or comment to let me know about your favorite feature, extension or theme.