JavaScript for Line of Business Applications

Variable scoping has always been a part of every programming language. Whether we are using a class based object oriented language (e.g. Java/C#) or a class-less object oriented language, scope has a very important role to play.

What scope defines?
In easiest terms, scope defines the visibility of any variable/data. In JavaScript, you can define a piece of code (function/method) globally or you can keep it within an object and expose it for public use. The keyword 'this' has a special significance when it comes to JavaScript. Other languages also use the 'this' keyword but it needs some serious attention if you are trying to use or understand it in JavaScript world.

The original Smalltalk MVC is an elegant way to structure an application. Unfortunately, the JavaScript community takes more inspiration from Dr. Frankenstein than from Smalltalk. The community appears to have done its best to saw off many good parts from MVC and bolt on unnecessary ugly bits to create framework monsters unsuitable for building real-world JavaScript applications.

I hope this article will remove the necessary historical digging to read and understand the implementation of Smalltalk MVC. Also, I hope it inspires better JavaScript frameworks and applications.

As JavaScript projects grow, they tend to become difficult to manage if you're not careful. We found ourselves running into common problems including code that was difficult to reuse or test, and code that broke when introduced in new pages.

Planning a front-end web application is about more than just picking a few JavaScript solutions to aid in the architecture and testing of a web application. While this might be where much of the front-end community focuses, seasoned developers know that building enterprise-grade software is much more than this.

In this article, I am going to describe 16 steps that front-end developers should go through when planning a front-end web application. These steps aim to cover the entire life-cycle of a front-end application. However, before diving in, I need to clarify a few front-end terms that remain unsettled in the industry.

“Latency Compensation” is one of the Seven Holy Principles of Meteor, which – as the legend goes – were handed down to the Meteor Development Group engraved on a burning Meteorite in the year Two Thousand And Eleven.

If you’re trying to insert a post in a database, you need, well, a database. This is where the database everywhere principle comes in: because Meteor can store a subset of the database on the client, it can perform operations against it and get a fairly good idea of what the result will look like on the server.

Instead of beating around the bush, I shall cut to the chase right away. Firstly, this blog is only for readers who have some idea about NOSQL. Secondly, the purpose of this blog is to give you a good idea of different types of NoSQL databases so that when you go for a particular NoSQL database type, someone says to you ‘Excellent Choice Sir’. Lastly, this blog is part of the MEAN stack series I have been working on and I will be taking up MongoDB after I am done with NoSQL database types. 

The open source Opa Framework for JavaScript makes web development rapid and secure.

Write simultaneously the frontend and backend code, in the same language, within the same module. Even better: the Opa Slicer automates the calls between client and server. No more manually written AJAX calls or value serialization!

And when auto is not enough, add hints to the code to enforce client or server-side, privacy, synchronous or asynchronous.

Opa generates JavaScript on the server too, using Node.js and MongoDB.

Applications built with Opa can be deployed in most cloud straightforwardly and scaled up or down easily.

Starting out with Ember.js is a lot like starting out with Rails -- there is a plethora of ways to achieve one thing. This is a good thing and a bad thing. It's good that the framework is flexible enough to support multiple and solid ways of implementing a feature, however, with a large team, a convention needs to be established for maintanability and overall sane-ness. So why not stick with the framework's conventions?

• Mobile First
• Responsive Design
• Semantic Markup
• Flexible Styles
• Accelerated Animations
• Extensible Configuration
• Scalable Spacing
• Reusable Code
• Progressive Enhancement
• Graceful Degradation
• Stable Codebase

This article shares some techniques and tools for building web apps using future friendly ES6 module syntax. We begin with an exploration of current module formats and ways to work both forwards and backwards in time.

For many years JS had a single widely accepted module format, which is to say,there was none. Everything was a global variable petulantly hanging off the window object. This invited risky propositions, too sweet to ignore, and some of us began monkey patching built in objects. Chaos prevailed. We had run amuck.The JS of that era was nightmarish, intertwined, lacking order and utterly without remorse.

As I dug in just a tad more, however, I found the frontend framework that Meteor ships with to be less desirable. The holistic approach of Meteor has led some to accuse Meteor of “trying to boil the ocean.” Regardless of which side of this debate you come down on, being able to use one of the existing best of breed client side frameworks is compelling, and AngularJS is my current favorite. I did some research and found that a few people had already started investigating how to use AngularJS with Meteor. I’m going to discuss three different solutions out there for solving this problem.

In this post, I’ll outline some recent observations and approaches to delivering sites for speed and broader access, and link out to various tools we are using to facilitate our approach. All of the tips mentioned in this post are implemented on this very site, and we’ve tested them heavily to ensure that they’re working as well as they can.

I’ll start with some high-level observations, then later I’ll dive into the more technical how-to. First, some general notes about page loading performance and what we aim to accomplish.