 Your new post is loading...
Your new post is loading...
Scoop.it!
![[Ember Conf 2014] - videos of talks | JavaScript for Line of Business Applications | Scoop.it](https://img.scoop.it/PfdDloGLylM2Hagvk9Vvnzl72eJkfbmt4t8yenImKBVvK0kTmF0xjctABnaLJIm9)
We'll be gathering 350+ of the top Ember developers from around the world and spending two full days deep-diving into the fundamentals, along with the latest and greatest. We're expecting the entire Core Team to attend, and a number of us will be giving talks, too. 
No comment yet.
Sign up to comment
Scoop.it!
From
scotch
Now let’s talk about a different scenario where we won’t always know how many fields or which fields we will have. There could be many scenarios for needing a dynamically built form. Let’s say that our application pulls data from that API for a form that we need to edit. For this example, we are going to get a list of users and we need to edit their email. The process for this would look something like:
To keep things simple, instead of pulling a list of users from an API, we will be creating the array right in the JavaScript file. Easy cheese. Here is our list of users and we’ll be editing their email addresses.
Scoop.it!
Frisby is a REST API testing framework built on node.js and Jasmine that makes testing API endpoints easy, fast, and fun. Inspector helpers are useful for viewing details about the HTTP response when the test does not pass, or has trouble for some reason. They are also useful for debugging the API itself as a more user-friendly alternative to curl.
Scoop.it!
Algorithms are a fascinating use case for visualization. To visualize an algorithm, we don’t merely fit data to a chart; there is no primary dataset. Instead there are logical rules that describe behavior. This may be why algorithm visualizations are so unusual, as designers experiment with novel forms to better communicate. This is reason enough to study them. But algorithms are also a reminder that visualization is more than a tool for finding patterns in data. Visualization leverages the human visual system to augment human intellect: we can use it to better understand these important abstract processes, and perhaps other things, too.
Jan Hesse's insight:
fine reading with lots of examples on ordering and randomness
Scoop.it!
JavaScript is having a great year. With the continuation of web development,Node.js, and even Apple adding JavaScript as a replacement for their AppleScript. You may be waiting until you have to learn JavaScript, but maybe you should learn JavaScript to make you a better developer. While many of us have been snickering, something amazing has happened. JavaScript has matured and prospered. It’s been adopted as a real language in many different scenarios. Certainly it’s biggest use is in client-side web development, but using JavaScript for mobile and server programming is getting more and more common.
Scoop.it!
SEPARATE MODULE CHOICES FROM YOUR CODE
Scoop.it!
If you are an experienced C# developer, coming into JavaScript world for application development, you will end up making few common mistakes. However some of the mistakes you would make are due to the basic differences between any strongly typed language [C#, Java etc.] and a dynamically typed language [JavaScript, Python etc]. Although dynamic feature was added to C# version 4.0, its initial design was based on static typing. Contents: * 1. Equality Operator
Scoop.it!
ere’s a brand new, revisited tutorial for Express.js 4, Node.js and MongoDB (Mongoskin) free-JSON RESTful API server. Contents:
This Node.js, Express.js and MongoDB (Mongoskin) tutorial will walk you through writing the test using the Mocha and Super Agent libraries. This is needed for a test-driven development building of a Node.js free JSON REST API server. The server application itself will utilize Express.js 4.x framework and Mongoskin library for MongoDB. In this REST API server, we’ll perform create, read, update and delete (CRUD) operations and harness Express.js middleware concept with app.param() and app.use() methods.
Scoop.it!
The Protractor community is getting bigger by the day. We have blogged about ways to get hands-on with Protractor and how to test your AngularJS apps with it. In this blog, let’s look beyond Protractor’s support for writing UI Tests for AngularJS. Let’s examine a few of Protractor’s shortcomings and then understand how they can be overcome with Page Objects.
Scoop.it!
Before the days of JQuery and MVC and CustomValidation attributes, our approach was to decorate our models with a custom attribute that could be used to enforce complex validations, like ranges or lists. Unfortunately, that meant that if we wanted to perform validation at each layer (as one should), we needed three different sets of code to evaluate those restraints - one at the db (that was fun), one at the business logic layer, and, of course, one at the user interface. Well, perhaps not 'of course', since it wasn't natural in those days to have client-side validation; and although we encouraged it, for these reasons it wasn't always done.
Scoop.it!
AngularJS was born out of the need to find a better way to create enterprise web applications and, given the meteoric rise of the framework in the last year, it's safe to say that AngularJS has succeeded in grand fashion. Learn how to create a simple AngularJS website and add in animations in just a few short steps using the animation API.
Scoop.it!
Torii is a set of abstractions for handling authentication and session management in Ember.js applications. Torii encourages you to work with composable, RESTful APIs by isolating authorization (through providers) from authentication (through adapters). Torii is composed of just three primitives, and just three possible actions. Torii powers your JavaScript application’s session so that you only need to implement the exchange of an authorization object for a session object and current user. All the social authorization concerns stay out of your way.
Scoop.it!
From
github
Cosmos is a JavaScript user interface framework that cares about data clarity and component autonomy. It prevents scaling complexity by enforcing a zero-bootstrap policy and by having data structures dictate code logic and not the other way around. Built on top of Facebook's React, Cosmos glues components together and provides a uniform structure between them. Components are self-contained, UI building blocks.
|
Scoop.it!
Building an app on Parse makes your data available via the Parse REST API. Using that API, ember-cli and Ember-Data, I’ll show you how to get started porting your native app to the mobile web.
Scoop.it!
Ampersand.js splits things apart as much as possible. For example, ampersand-collection makes no assumptions about how you’re going to put data into it, what types of objects you’re going to store, or what indices you’re going to want to use to retrieve them. It follows the tiny module pattern. But, what if you want that stuff? Well, that’s easy, we just have another tiny module that layers in that functionality. There’s a RESTful ampersand-rest-collection we just pre-bundle and publish it as a module for convenience, the code that combines them is hilariously simple. You see the exact same pattern in ampersand-state and ampersand-model. “State” is the base object that “model” is built on. But model goes the additional step of including the RESTful methods.
Jan Hesse's insight:
Scoop.it!
Polymer brings an implementation of material design to the web. The paper elements range from controls to effects and user interaction. Recap everything Polymer at Google I/O 2014. Watch sessions videos and DevByte shorts.
Scoop.it!
In this article, Jeremy Likness shows how to connect to WebSockets using both message-based and real-time connections from Windows Store apps.
Scoop.it!
This article introduces the Browserify tool. It also shows how Browserify can be integrated with Grunt and Gulp. any of us now work with JavaScript modules – independently functioning components that come together to work as a cohesive whole, yet can happily have any component replaced without causing armageddon. Many of us have been using the AMD module pattern and RequireJS to accomplish this neatly.
Scoop.it!
I'm mostly concerned with the core problems of data binding and componentizing UIs. After much research and usage of the technologies mentioned above, I found React to provide the best solution. I ask that you set aside your framework prejudices and read this post with an open mind. This post is not to evangelize React specifically, but to explain why its technique is profound. I want developers steeped in other technologies to take a hard look at these techniques, particularly those involved in Web Components.
Scoop.it!
Sometimes we want to share objects by reference for performance and space reasons, but we don’t want them to be mutable. One motivation is when we want many objects to be able to share a common entity without worrying that one of them may inadvertently change the common entity. JavaScript provides a way to make properties immutable:
Scoop.it!
There are several reasons you would want to render to an iFrame but the main benefit is style encapsulation. We can safely style our components without having to worry about style inheritence or CSS specificity and vice versa not affecting the parent document styles. The other benefits that are beyond the topic of this post are guaranteed paint layer and layout boundaries. Basically causing paints and reflows won’t effect the parent document as iFrames are essentially a new window.
Jan Hesse's insight:
Scoop.it!
From
github
An AngularJS service to bind Angular models with sailsjs backend models using socket.io. What it does:
Scoop.it!
Google’s Web Starter Kit provides much of that boilerplate as downloadable content, so developers can speed up their projects and get site building. In its introduction to the kit, Google divides the workflow in to three functions: developers can pick a template, build the site and test it out.
Scoop.it!
This article examines some of the "magic tricks" performed by modern frameworks. The author then pulls back the curtain to show how the magic works.
Scoop.it!
Rich-clients are back. But the new rich-client is the browser. No more plug-ins or ActiveX objects in sight. Instead you’ll find new, more powerful JavaScript libraries enabling you to more easily build large-scale applications directly in the browser. You’ll still need to be able to work with the disconnected nature of websites, but you no longer need to worry about a page-based model. One of these libraries is AngularJS from Google. In this article, I hope to get you started by showing you how it works and hopefully why you should be using it.
|
