Almost everyone involved in web development knows jQuery or at least heard of it. Being simple and concise, it makes web developers’ life much simpler. But could it be a solution to every problem? Unfortunately not. Once you decided to create more complex web apps, you are to face a problem, as there is no easy way to make your UI and data communicate with each other dynamically. And you need a library which will provide you with a more sophisticated way of communication between your UI and the underlying data model. And here is where Knockout (KO) could help.
What is Knockout?
- Dependency Tracking
The right parts of your UI are automatically updated whenever your data model changes. This is achieved by the two way bindings and a special type of variables called observables. You don’t have to worry about adding event handlers and listeners for dependency tracking.
- Declarative Bindings
This becomes useful when your application becomes more complex and you need a way to display a rich structure of view model data, thus keeping your code simple. Knockout can use alternative template engines for its template binding. It has a native, built-in template engine which can be used right away.
- Compatibility and Extensibility
Knockout is compatible with any back-end technology and on the front-end it does as much or as little as you decide. It leaves many decisions to you to make, thus letting pick the best tool to meet your specific needs. Knockout doesn’t care about how you communicate with the server or how you choose to do routing, but there are several third party libraries that do a fine job of these things (like sammy.js for routing and upshot.js for data-access). It goes without mentioning that it works fine next to jQuery. Knockout is also easily extensible. To modify or extend the default functionality, it offers features like custom bindings, and custom functions. There are also several plugins already written for KO.
- Ease of Learning and Use
Some additional benefits are the following:
• It can be added on top of your existing web application without requiring major architectural changes
• It’s compact – around 13kb after gzipping
• It works on any mainstream browser (IE 6+, Firefox 2+, Chrome, Safari, others)
• Comprehensive suite of specifications (developed BDD-style) means its correct functioning can easily be verified on new browsers and platforms
- HTML views can get messy as declarative bindings increase. This can be weakened to some extent through the use of custom bindings, computed observables and by attaching events to the DOM using jQuery instead of using the data-bind attribute.
- Additional functionality like data-access and url-routing are not included. If you are looking for an end to end solution that offers a complete toolbox of common web-app functionality, you should probably check out such frameworks as Angular or Ember.
Knockout VS jQuery
Knockout.js is not a replacement of jQuery (as well as of Prototype, or MooTools). It doesn’t attempt to provide animation, generic event handling, or AJAX functionality (however, Knockout.js can parse the data received from an AJAX call). Knockout.js is focused only on designing scalable and data-driven UI.
Moreover Knockout.js is compatible with any other client-side and server-side technology. It also acts as a supplement to the other web technologies like jQuery and MooTools.
Although you will need to use Knockout with jQuery at the same time, in some cases like animated transitions, Knockout itself doesn’t depend on it. Another thing you need to understand is that Knockout doesn’t compete with jQuery – they both do excellent job; each one in its own direction. And if you want to get the most benefits you should use them together.
Knockout is the simplest of all the frameworks as well as one of the smallest. It does not claim to be able to solve all your problems, but it does claim to do a few useful things and do it better than the alternatives. In the words of Knockout creator Steve Sanderson, it is “low risk” because its uses are focused and it is compatible with any other technologies you are using and you can use it in a very small part of your application or your entire application. For someone who wants to take their project to the next level without too much risk, knockout is a great choice.
Hope you found the information in this article useful. Your valuable feedback, question, or comments about this article are always welcome!
There is no doubt that mobile industry is one of the most intensely growing nowadays. Any product that earlier used to be desktop or web is moving towards going mobile. Everyone is taking designing experiences for smaller screens seriously. As for the web, we’re seeing swarms of recently updated sites that are employing responsive design or more mobile-friendly layouts. This is quite critical, especially when you consider that accessing the web from mobile devices is on track to surpass desktop usage in a just a year or two.
With so many mobile apps/sites out there you have to do all it takes to deliver a good mobile product that will be competitive on the market. The key input for success here often is conditioned by the convenience of mobile services. You have to start predicting what the customer wants to see when they try a mobile application or website. The use of mobile context in delivering mobile experience is just one of the big challenges that application developers face. Here’s a number of the most important challenges we see.
1. Mobile Context
There has always been emphasis on context – the idea of being sensitive to where users might be and what they might be doing at the same time that they’re using your app/site. Is a user in line at the grocery store or on the living-room couch? Is a user connected to the Internet via Wi-Fi access, with fast page loads, or an infuriatingly weak Internet connection? Are both of the user’s hands holding the device in landscape orientation, or is the user using only the right thumb to navigate the interface in portrait mode? We have to think about all of this. Basically the customer’s mobile context consists of:
Preferences: the history and personal decisions the customer has shared with you or with social networks.
Situation: the current location, of course, but other relevant factors could include the altitude, environmental conditions and even speed the customer is experiencing.
Attitude: the feelings or emotions implied by the customer’s actions and logistics.
Getting a good contextual awareness will require collecting information from many sources. For instance it could be mobile device itself, the local context of devices and sensors around them an extended network of things they care about and the historical context of their preferences. Gathering this data is a major challenge because it will be stored on multiple systems of record to which your app will need to connect.
2. Device Proliferation
Another challenge facing mobile developers is device proliferation. It looked like mobile app development process was pretty well defined: build your app, make sure it looks pretty on a 4-inch smartphone and a 10-inch tablet, then submit it to an app store. Most app developers prioritized a few popular devices, such as the iPhone, the Samsung Galaxy S III and the iPad.
It’s not quite that easy now, and it’ll be much tougher in the near future. Picking the most popular devices will become more of a challenge as device types and platforms proliferate. Google and Apple already support tablets of different sizes and, with Windows 8 now shipping, developers can expect to find a whole range of larger touch-sensitive devices, such as Hewlett-Packard’s Envy series.
3. Voice rather than Touch
There are a lot of situations where you would want to build voice input into your app today. For a running or fitness app, a phone is likely to be strapped to a person’s sweaty arm. The same is true while driving. Modern applications are to let people use their devices while keeping their eyes and hands off it.
4. Hybrid Applications
With each release, popular mobile operating systems get better at supporting HTML5 and its attendant APIs. That capability will let companies reuse more code across multiple devices, which will be important in keeping app development costs down taking into account the proliferation of connected devices and form factors.
5. Cloud Powered Mobile Applications
With the power of the cloud, the mobile application market is about to change radically. Several industry analysts predict that mobile applications will gradually move to the cloud and move away from being installed and run directly from the handsets themselves. Instead, cloud powered mobile applications are accessed and executed directly from the cloud through a mobile web browser interface and several technologies facilitating this change are already available. HTML5, for example, is necessary for enabling caching on the handset, so that users will experience uninterrupted service levels despite fluctuations in network service delivery.
Cloud powered mobile applications are not limiting their choice to one platform. Application developers also have real advantages from mobile cloud computing. The largest benefit is that it allows them to have access to a larger market. This means developers will have a much wider market which means they can bypass the restrictions created by mobile operating systems. But with greater developers’ power comes greater responsibility for security and performance. Expect more developers to be on call for application support in the new model, using triage to handle defects and investigate degradation to production services. Those tasks have traditional been the domain of systems administrators. Expect IT operations personnel to become integrated into development teams and to start their work at the inception of an idea.
I think the challenges mentioned are some of the most important ones. What are the challenges you have already faced in the mobile development? Even more interesting to hear about the challenges you are envisaging for the near future! As usual many thanks for sharing your thoughts!
Within a short period of time since its initial release in late 2009, Node.js has gained the interest of thousands of experienced developers, grown a package manager and a corpus of interesting modules and applications, and even became the reason for a number of startups to appear. You may have heard about node.js, or read articles claiming how great it is; you may have even read some technically focused explanations on why it is so good.
So let’s try to understand what it is about this technology that makes it interesting to developers. And what the commercial pluses of adopting Node.js when developing and deploying web applications.
I’ve carefully look through a number of forums and experts’ opinions in these regards. Below you could find some main reason why it is worth to use Node.js.
* Node.js was designed to be great at transporting small bits of information around the Internet very quickly, and in real-time. Server-side events, instant messaging apps, real-time games, and collaboration tools are all great example of this.
* Also the reason to use Node.js is based around the idea of not waiting on things. Instead of waiting for a db query to return results, it just triggers a DB query and sets a callback event. Then, while the query is processing, your program can be doing other things (like handling another request). This is what makes Node.js seem so fast.
* Node.js allows designing of scalable applications at a very high speed. The importance of scaling is going to be at a premium for all applications going forward. One of the secrets to Node’s massive scalability is the event-loop. This construct, which is fundamental to the architecture of Node, provides a completely different model for the handling of client connections than those of traditional web server technologies. The event- loop, which your Node.js applications are naturally built upon, transparently treats the connections from your clients extremely lightly. The memory usage per client is negligible, and as such a single Node.js server can handle hundreds of times more clients than a server with other languages.
These are only some of the reasons I could provide and answer the question why this library gains popularity and worth to be working with.
Hope this information would be of interest and of use to you. Please feel free to share your thoughts and opinions why we would need to use Node.js. By the way how you think what to expect for it the future?
Let`s start from the brief history of the two.
- Sending HTML page data to server using AJAX;
- Animating HTML element;
- Validating the HTML form;
- Storing user information that may help for Web Analytic, Ad tracking etc.
Mostly jQuery focuses on designers and inexperienced developers, still it could be of interest to experienced programmers as well. Here I will try to enumerate the reasons why:
1) Element’s selecting. Every jQuery operation starts from selecting one or more nodes from the DOM. jQuery’s selection syntax is an interesting hybrid of CSS 1, 2, bits of CSS 3, some XPath and a few custom extensions as well.
3) The $ function. You could say it is not true that that jQuery introduces only one object in the global namespace as there is also a $: the $ symbol is also set up as a shortcut for jQuery. This makes enough gently: if you want to back your former function $ (for example, if you have a piece of code based on Prototype), you can call jQuery.noConflict (), to return to his old the $. At the beginning you could considere the widespread using $ in jQuery is no more than a clever trick. But for some reason thinking of it in terms of the jQuery symbol makes everything seem a lot more sensible
5) Manipulating with DOM. jQuery offers a few smart ways of making large scale manipulations to the DOM. The first is quite surprising: the jQuery function can take a snippet of HTML which it will turn in to a DOM element.
6) The returned beast. Object, which is returned by the selectors jQuery, could be quite interesting. It represents a set of DOM-elements and behaves a bit like an array—it has a length property, items can be accessed by index and (most importantly) Firebug treats it as an array when displaying it in the interactive console. This is a clever illusion; the collection is actually a jQuery object, incorporating a large number of methods which can be used to query, modify and extend the collection of selected elements.
There are three principle categories of jQuery methods: those that manipulate all of the matched elements, those that return a value from the first matched object, and those that modify the selection itself. If you have Firebug you can try these out interactively: use this Insert jQuery bookmarklet first to load the jQuery library in to any page, then paste the code examples in to the Firebug console. I would like to note a convenient symmetry of these methods: they are used for display attributes (taking 2 arguments passed to or from a number of properties of the object), and to read the values of these attributes (if only one argument). This symmetry is used throughout jQuery, which greatly facilitates the storage API.
8) jQuery and Ajax. jQuery has the best API for working with Ajax. The most simple form of an Ajax call looks like jQuery(‘div#intro’).load(‘/some/fragment.html’). This performs a GET request against /some/fragment.html and populates div#intro with the returned HTML fragment. It’s a neat shortcut, but what if you want to do something more advanced like display an Ajax loading indicator? jQuery exposes custom events (ajaxStart, ajaxComplete, ajaxError and more) for you to hook in this kind of code.
9) Extensions. Considering the whole set of features as standard, it is worth noting that uzhaty jQuery version is only 20 KB, and even less if you use archive (. Gz). Additional functionality that extends beyond this delivery can be arranged with the help of extensions that can (and do) to add new methods to an existing jQuery. If you want, you can do something like this: jQuery (‘p’). bounceAroundTheScreenAndTurnGreen(); The extension mechanism in jQuery provides documented methods for adding them to the system. Simplicity and ease of use have attracted a large community of authors such extensions, the extensions directory has more than a hundred examples. Another nice feature is the ability to add your own selectors as well as their own methods. MoreSelectors expansion adds methods like div: color (red), which, for example, selects all div with red text.
10) Several words about leaky abstractions. When studying jQuery with more respect, you could struggle with one philosophical blocker. In certain cases, jQuery uses a truly unique methods to achieve a particular function: some parts (such as source code selectors) of this library look scary. If you do so , it requires an understanding of how the library works. To understand this, you need to know some basic concepts, the differences between browsers and a set of methods, which the library uses to get around them. No library can protect you 100% against weird browser behaviour, but as long as you have a grounding in the underlying theory you should be able to figure out if a problem stems from your own code, your library or the underlying implementation.