The Modern Magicians of JavaScript Development

In the ever-evolving landscape of web development, JavaScript stands as the cornerstone, powering the dynamic and interactive elements that have become the standard for modern web experiences. Among the myriad of tools and frameworks available, a few have risen to prominence, each bringing its unique approach to solving the challenges of web development. Let’s dive deeper into the magic behind these frameworks and understand why they are the top choices for developers around the globe.

React: The UI Architect

Developed by Facebook, React has revolutionized the way developers think about building user interfaces. Its component-based architecture allows for reusable UI elements, making code more manageable and development faster. React’s virtual DOM optimizes rendering, making it incredibly efficient. This efficiency, combined with its flexible nature, offers developers a blissful experience, hence earning its place at the top of many developers' lists.

Advantages:

• Component-Based Architecture: Encourages reusability and modular design.
• Virtual DOM: Enhances performance by minimizing direct DOM manipulation.
• Large Ecosystem: Extensive community support, libraries, and tools.

Challenges:

• Steep Learning Curve: Especially for beginners.
• Boilerplate Code: Managing state and props can become cumbersome.

Vue: The Progressive Craftsman

Vue.js stands out for its progressive nature, allowing developers to integrate it into their projects where needed, bit by bit. This framework is loved for its simplicity, yet it does not compromise on power or versatility. Its gentle learning curve makes it accessible to beginners, while its robustness satisfies the needs of advanced projects. Vue's detailed documentation and supportive community add to its magic, making web development a more approachable and enjoyable craft.

Advantages:

• Progressive Framework: Can be integrated into existing projects incrementally.
• Ease of Learning: Simple syntax and structure.
• Flexibility: Works well for both small projects and large applications.

Challenges:

• Smaller Ecosystem: Compared to React or Angular.
• Lack of Big Company Support: Primarily maintained by the open-source community.

Svelte: The Invisible Hand

Svelte introduces an innovative approach to building web applications. Unlike other frameworks that add overhead by requiring the browser to do heavy lifting, Svelte shifts that work to compile time. This process results in highly efficient imperative code that directly updates the DOM, effectively making the framework disappear at runtime. This unique characteristic leads to faster load times and enhanced performance, capturing the interest of developers looking for an efficient and modern approach to web development.

Advantages:

• No Virtual DOM: Direct DOM manipulation for optimal performance.
• Lean and Efficient: Compiles to highly efficient JavaScript code.
• Simplified Syntax: Intuitive and easy to understand.

Challenges:

• Smaller Ecosystem: Fewer libraries and tools compared to React or Vue.
• Newer Framework: Still growing in terms of community and support.

Angular: The Robust & Scalable Solution

Developed by Google, Angular is a comprehensive solution for building complex and scalable web applications. It’s a full-fledged MVC (Model-View-Controller) framework that encourages developers to write clean, maintainable, and testable code. Angular’s rich feature set includes two-way data binding, modular development, and an extensive suite of tools, making it a go-to framework for enterprise-level applications that demand robustness and scalability.

Advantages:

• Full-Featured: Includes everything you need for large-scale applications.
• TypeScript: Built with TypeScript, offering static typing and better tooling.
• Strong Community: Backed by Google with extensive support and resources.

Challenges:

• Complexity: Can be overkill for smaller projects.
• Steep Learning Curve: Due to its comprehensive nature.

Next.js: The Jamstack Maestro

Next.js is a React-based framework that brings the best of both server-side rendering (SSR) and static site generation (SSG) to the table. It enables developers to build fast, scalable applications that benefit from improved SEO and user experience, thanks to its pre-rendering capabilities. With features like automatic routing, API routes, and built-in CSS support, Next.js is a powerful solution for developing Jamstack websites and applications that stand out in the modern web.

Advantages:

• Hybrid Rendering: Combines SSR, SSG, and client-side rendering.
• SEO-Friendly: Pre-rendering improves search engine visibility.
• Developer Experience: Simplifies routing and API handling.

Challenges:

• React Dependency: Must be familiar with React to use effectively.
• Configuration Overhead: Some setup is required for optimal use.

Nuxt.js: Vue’s Versatile Companion

As to Vue what Next.js is to React, Nuxt.js provides a framework for creating Vue.js applications with an emphasis on server-side rendering and static site generation. It simplifies the process of developing universal Vue applications, making it easier to get the benefits of SSR for SEO and performance without the complexity. Nuxt.js aims to make web development painless by offering a powerful and intuitive framework for the Vue.js community.

Advantages:

• SSR and SSG: Out-of-the-box support for server-side rendering and static site generation.
• Modular Architecture: Easy to extend with modules.
• Enhanced Developer Experience: Simplifies many of Vue’s configurations.

Challenges:

• Learning Curve: Requires understanding of both Vue and Nuxt concepts.
• Limited Ecosystem: Smaller ecosystem compared to React/Next.js.

Express: The Backend Powerhouse

Express is not just another framework; it's the backbone of many web applications built on Node.js. Known for its speed and minimalism, Express provides a thin layer of fundamental web application features, without obscuring Node.js features that you know and love. Whether you're building APIs, web applications, or real-time services, Express offers the flexibility and performance needed to deliver fast and efficient back-end solutions.

Advantages:

• Minimalistic: Lightweight and unopinionated, offering great flexibility.
• Speed: Built for performance with asynchronous architecture.
• Community Support: Large ecosystem of middleware and plugins.

Challenges:

• Manual Configuration: Requires more setup for advanced features.
• Lack of Built-In Features: Unlike full-stack frameworks, more manual coding is needed.

Nest.js: The Enterprise Enchanter

Nest.js, built on top of Express, introduces a powerful framework for building efficient and scalable server-side applications. With a strong emphasis on TypeScript, Nest.js offers an out-of-the-box architecture that is highly modular and easily testable. It's designed with the principles of object-oriented programming, functional programming, and reactive programming in mind, making it a solid choice for enterprise-grade applications.

Advantages:

• TypeScript-First: Built with TypeScript, promoting type safety and modern JavaScript features.
• Modular Structure: Encourages a highly organized and maintainable codebase.
• Extensive Ecosystem: Integrates smoothly with many libraries and tools, making it versatile.

Challenges:

• Learning Curve: Especially if you’re new to TypeScript or Angular-style architecture.
• Complexity: May be overkill for smaller projects or simple APIs.

---

The landscape of JavaScript frameworks is diverse, with each offering its unique strengths to address different aspects of web development. Whether you're drawn to the blissful UI development of React, the progressive enhancement of Vue, the innovative efficiency of Svelte, the enterprise-scale robustness of Angular, the SSR and SSG prowess of Next.js and Nuxt.js, the back-end capabilities of Express, or the enterprise-level magic of Nest.js, there's a framework out there that fits your project's needs. The choice of framework often depends on the specific requirements of the project, the team's expertise, and the desired user experience. As the web continues to evolve, so too will these frameworks, pushing the boundaries of what's possible and continuing to enchant the world of web development.

Add json config to Heroku config variables

If you have a multiline JSON credentials file such the one you get from Google Firestore, you can simply do that if you already have Heroku cli installed in your machine as follows:

`heroku config:set FIRESTORE_CREDENTIALS="$(< /path/credentials.json)"`

You may also have to append the app name with `-a app-name-here`

Rails Benchmark Execution Time

Sometimes we need to benchmark the execution time of a code segment to check the performance.
For this we can use the `Benchmark` library available in Rails like below.

puts '====== Start benchmark ========'
time = Benchmark.realtime {
  ... Code being tested goes here ... 
}
puts time
puts '====== End benchmark =========='

Disable Ember CLI Mirage in a specific test

There can be a scenario where you want to disable ember-cli-mirage server in a specific test file; acceptance specially. You can do that by shutting down the Mirage server in `beforeEach()` in an acceptance test. For example,

```
moduleForAcceptance('Acceptance | test name', {
  beforeEach() {
    server.shutdown();
  }
});
```

Run Ember Tests without running `ember t -s`

It is possible to run the Ember server with `ember s` on one port 4200 by default and testing with `ember t -s` on port 7357 by default.

However, it is possible to run the server and run the tests on that same port (4200) as well just by navigating to `http://localhost:4200/tests` after running `ember s`

Merge pdf files into one pdf file using GhostScript on Linux

Command:

gs -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -sOutputFile=finished.pdf file1.pdf file2.pdf

Explanation:

• gs starts the Ghostscript program. 
• -dBATCH once Ghostscript processes the PDF files, it should exit. If you don't include this option, Ghostscript will just keep running. 
• -dNOPAUSE forces Ghostscript to process each page without pausing for user interaction. 
• -q stops Ghostscript from displaying messages while it works 
• -sDEVICE=pdfwrite tells Ghostscript to use its built-in PDF writer to process the files. 
• -sOutputFile=finished.pdf tells Ghostscript to save the combined PDF file with the specified name.

Crop a video file using ffmpeg

If you want to crop the file beyond 1 min then use the -t flag and as follows. It will generates the output.avi video with the first 60 seconds of the input.avi

ffmpeg -t 60 -i input.avi -an -vcodec copy output.avi

CSS clearfix

.group:before,
.group:after {
  content: "";
  display: table;
}

.group:after {
  clear: both;
}

.group {
  zoom: 1 /* IE6&7 */
}

Make Odin flashable tar.md5 on Linux

Steps:

1. tar -H ustar -c image_1 image_2 > your_odin_package.tar
2. md5sum -t your_odin_package.tar >> your_odin_package.tar
3. mv your_odin_package.tar your_odin_package.tar.md5

You are done!!!

Enjoy!

Gnome online accounts and google gmail two step verification

If you are stuck in authenticating your gmail (google) account with Gnome's 'Online Accounts', here's the quick solution to resolve it.

Prior to that you have to create an application specific password for this authentication.

Follow the following steps OR use this link directly.
Manage your application specific passwords

1. Go to https://www.google.com/settings/account
2. Select 'Security' from left.
3. Scroll down to '2-step verification' and select 'Manage your application specific passwords'.

Then

• Enter a name for in the field and 'Generate password'
• Keep the generated password copied somewhere or in the memory.

• Go to 'Online Accounts' in Gnome and add your google account using your login password (not the generated one).
• Now go to 'Passwords and Keys' application (also know as Seahorse).
• Search for 'GOA google' and your specific account you just added above.

• Get properties and click show password.

• At the end of that string, you can find your password as "'password': <'your password'>". Replace 'your password' with the generated password above.

• That's it. You're done with the authentication.

As a last note, if 'Online Accounts' is still trying to connect without success try logging out from your Gnome session and logging back in.

Have fun!

Android (Contacts): How to lookup and add contacts

This is how you can look-up for a specific contact in Android and do whatever you want if the contact is available or not.

The following code segment shows how the contact is programmatically added to contacts.

Check for an existing number in the Android contacts

Uri lookupUri = Uri.withAppendedPath(ContactsContract.PhoneLookup.CONTENT_FILTER_URI,
                                                                   Uri.encode(CommonVariables.merchantPhone));
String[] mPhoneNumberProjection = {
   ContactsContract.PhoneLookup._ID,
   ContactsContract.PhoneLookup.NUMBER,                  
   ContactsContract.PhoneLookup.DISPLAY_NAME
};

Cursor cur = context.getContentResolver().query(lookupUri,mPhoneNumberProjection, null, null, null);

if (cur != null && cur.moveToFirst()) {
   // The code to be executed if the phone number is available
}
else {
   // The code to be executed if the number is not available
}

Add a new number to the Android contacts

ArrayList op_list = new ArrayList();
op_list.add(ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI)
.withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, null)
.withValue(ContactsContract.RawContacts.ACCOUNT_NAME, null)
.build());
 
op_list.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
.withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
.withValue(ContactsContract.Data.MIMETYPE,  ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)
.withValue(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME, CommonVariables.merchantName)
.build());

op_list.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
.withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)  .withValue(ContactsContract.Data.MIMETYPE,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
.withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, CommonVariables.merchantPhone)
.build());
 
op_list.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
 .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
 .withValue(ContactsContract.Data.MIMETYPE,ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)
 .withValue(ContactsContract.CommonDataKinds.Email.DATA, getResources().getString(R.string.merchant_email))
    .build());

try {
  ContentProviderResult[] results = getContentResolver().applyBatch(ContactsContract.AUTHORITY, op_list);
  Toast.makeText(AmountSet.this, getResources().getString(R.string.msg_contact_added), Toast.LENGTH_LONG).show();
} catch(Exception e){
  Toast.makeText(AmountSet.this, getResources().getString(R.string.msg_contact_error_adding), Toast.LENGTH_LONG).show();
  e.printStackTrace();
}

Android: how to draw a horizontal ruler.

<View
android:layout_width="fill_parent"
android:layout_marginTop="10dp"
android:layout_marginBottom="10dp"
android:layout_height="1dp"
android:background="?android:attr/listDivider" />

You can just enter the above code segment in the interested layout xml file and in the place where you want the horizontal ruler and change the android parameters according to your needs of the Android application.

Have fun.

Mac OS X Enable/Disable Dashboard

This is a quick way to enable or disable the mac os x's shining dashboard.

Enable:

defaults write com.apple.dashboard mcx-disabled -boolean YES

killall Dock

Disable: 

defaults write com.apple.dashboard mcx-disabled -boolean NO

killall Dock 

C# Format string with a number to two decimal places

formattedValueFrom =  String.Format("{0:0.00}", decimal.Parse(row["ValueFrom"].ToString().Trim()))

row - A DataRow in a DataTable
ValueFrom - A column in the DataRow

Gamai Pansalai, Nubai Daagabai...

A Bug's Life...

Not so far... (The Moon)

Say Cheese. Just got out of the nest.

The woody wood pecker. Starting to dig in.

Access Localhost Web Server (Host) through VirtualBox

Say that you want to install RHEL on a virtual machine in VirtualBox using the HTTP method (via network). Then you can setup a repository on your localhost using the first 4 of your 5 RHEL installation CDs and then add them to the local web server and access them through NAT in VirtualBox.

• After copying all the binaries (from first 4 CDs) to the preferred location, configure the httpd.conf located at /etc/httpd/conf/ (in Fedora 13) by assigning an alias to the copied location.
• eg:

               Alias /install "/install"
              <directory>
                   Options Indexes
                   AllowOverride None
                   Order allow,deny
                   Allow from all
              </directory>
             

• Boot the virtual machine using the first RHEL cd and at the boot screen  type "linux askmethod" (without quote) and press
  
• Select the HTTP method from the menu when asked
• Enter 10.0.2.2 as the IP address and the alias as the location ("install" in this case)
• The installation should pick up the repository and you are good to go. :)

Good Luck!