 Your new post is loading...
Your new post is loading...
Scoop.it!
Part 0: Preface 
No comment yet.
Sign up to comment
Scoop.it!
From
tech
I'd like to talk about how to make the transition between two particular frameworks easier: React.js and Knockout.js If you have a large project, making the transition all in one big pull request might not be a feasible option. It's important to allow some sort of middle ground where the two code-bases or technologies can play nice with one another.
Scoop.it!
By now, you may have heard a lot of things about Web Components. Some people say it's the promise land, others say it has been oversold. Although they're not going to solve all your life's problems, they do provide a paradigm shift from the traditional approach of web development. If you still aren't sure about what exactly is Web Components or even why you should care about it, this session is for you. In this session Dmitry goes through a brief overview of the Web Component specifications and how they fit in to application development today. The talk also covers best practices available to developers to use with Web Components.
Scoop.it!
Arch is a front-end functional style application framework using React as a UI layer. Arch applications are isomorphic out of the box, including form processing. This means you write your application as if it was client-side only and Arch will manage the server-side portion. This also means you don’t get any control over the code running server-side, which is a design decision. The theory behind it is that any server-side code you need to run should sit in a separate server application which you talk to over an API.
Jan Hesse's insight:
Scoop.it!
From
ryanclark
React is an insanely powerful framework by the amazing developers over at Facebook. Implementing a virtual DOM, it allows us to render components super fast whilst removing any unnecessary overhead from DOM operations. React is often said to deal with the "V" out of the MVC architecture, however when you mix this with Flux, you can have a full blown front-end framework that allows you to easily keep your model and view in sync - more on Flux soon.
Jan Hesse's insight:
Scoop.it!
From
emberjs
As we approach the eve of the release of Ember 1.13-beta, it's a good time to talk about the transition plan for those of us who have Ember 1.11 and 1.12 applications. The Glimmer engine represents the third phase of major performance work on Ember in the past year (preceded by metal-views in 1.8 and HTMLBars in 1.10). Now that it's landed, we're going to move into the next phase of major performance improvements. Expect to see more about that once Ember 2.0 has shipped.
Scoop.it!
I know, I know it is too early to be building end to end apps with Angular 2.0. A MEAN stack app would typically consist of a server layer built with Nodejs & Express – Express being the web framework. MongoDB for data persistence & Angular as the client side MVW framework. First, we are going to setup an express app, build the REST API to Create, Read, Update & Delete todos and then integrate it with the Angular app.
Scoop.it!
In this video, we'll look at some steps we can take to optimize our for loops so they are as performant as possible. We're going to be doing this through the use of a demo web application, three different browsers with tests, and sample code.
Scoop.it!
Rust is an exciting new system programming language by Mozilla. In this post we explore Rust's concept of ownership that enables the language to achieve 100 % memory safety without garbage collection. Most languages (JavaScript included) use a garbage collector to ensure memory safety.
Scoop.it!
Scoop.it!
From
medium
Facebook introduced Flux about a year ago for client-side web application building and since then it has become one of the hottest tech in the web development scene. The task of Flux is to isolate business logic from the user interface logic by using dispatcher, stores and actions. The core idea is the unidirectional data flow which means that actions are propagated through the entire system in response to user interactions but they have no binding to the internal data model. As the name implies, Reactive programming is what React is made for. Actions happen eventually and they propagate through the event streams.Combination of those event streams forms the application’s state. After the event has propagated through the system, the new application state object is consumed by the subscriber and rendered by the root level React component. This makes the data flow dead simple.
Scoop.it!
From
wwwhere
wwwhere provides a list of tools and resources for people who make websites. Information found here is the result of a few years of collecting and organizing websites into bookmarks to make my job as a Front End Developer easier. A lot of effort has gone into selecting, organizing, categorizing and tagging each tool/resource on this site, but there is plenty of room for improvement and I’d love your help to make things better.
Scoop.it!
ExpandJS is a library containing 80+ custom elements and 350+ utility functions to kickstart your Web Applications. The elements follow Google's Material Design guidelines, allowing for beautiful and responsive interfaces. ExpandJS is built upon the latest web standards, leading to rapid development, reusability and high maintainability.
|
Scoop.it!
When writing React applications, it’s important to know when and when not to use state in components. In this post, I will review what I consider to be best practices for working with state. TL;DR:
These rules obviously have exceptions and should be violated when appropriate; though if you’re able to follow them most of the time, you will find that your components will be easier to break down, the tests will be easier to write, and the entire application will have fewer bugs. Let’s take a closer look at each of these rules.
Scoop.it!
One of the biggest and most common problems in front-end web development is state management. A developer is constantly focused on keeping the state object in sync with its view and the DOM representation. Users can interact with the application in many ways and it's a big task to provide a clean transition from one view state to another.
Scoop.it!
From
pouchdb
Fellow JavaScripters, it's time to admit it: we have a problem with promises. No, not with promises themselves. Promises, as defined by the A+ spec, are awesome. The big problem, which has revealed itself to me over the course of the past year, as I've watched numerous programmers struggle with the PouchDB API and other promise-heavy APIs, is this: Many of us are using promises without really understanding them. Some people try to explain promises as a cartoon, or in a very noun-oriented way: "Oh, it's this thing you can pass around that represents an asynchronous value." I don't find such explanations very helpful. To me, promises are all about code structure and flow. So I think it's better to just go over some common mistakes and show how to fix them. I call these "rookie mistakes" in the sense of, "you're a rookie now, kid, but you'll be a pro soon."
Scoop.it!
From
segment
Deku is our library for building user interfaces. It supports many of the features you’re familiar with in React but aims to be small and functional. You define your UI as a tree of components and whenever a state change occurs it re-renders the entire tree to patch the DOM using a highly optimized diffing algorithm. The whole library weighs in at less than 10kb and is easy to follow. It’s also using npm so some of those modules are probably being used elsewhere in your code anyway. It uses the same concept of components as React. However, we don’t support older browsers, so the codebase is small and component API is almost non-existent. It even supports JSX thanks to Babel.
Jan Hesse's insight:
Scoop.it!
Normally in these screencasts I would show you a bunch of code and teach you how to write code, and if that's what you're looking for there's over 30 other screencasts on this website that can help you do that. But today, in just 20 minutes (oops, it was 33…), I want to give you a complete overview of Ember in the ecosystem, so I don't have enough time to in the depth in one technology. But I've got just enough time to talk about many technologies, and the philosophy that holds them together.
Scoop.it!
Arik Grinstein's curator insight,
May 19, 2015 12:32 PM
Great Topics. So many interesting things and so little time . Catchup time!
Scoop.it!
From
auth0
Learn how to create a real world angular 2 app using Pipes, Directives, Components, DI, ES6 and much more! We'll implement from Authentication to calling an API and everything in between.
Scoop.it!
In this article Christian Johansen gives you an example of how immutability can be used with React, the well-known library developed by Facebook. In my previous article I mentioned that tracking changes can be drastically improved because we can short-circuit the expensive diffing algorithm in libraries like React. When you give React some new data, it calls theshouldComponentUpdate() function on all the components. If this function returns false, React won’t diff this component with the existing version, so the library won’t re-render the elements that make the component. This potentially saves a lot of work, and can lead to a massive improvement in performance. Let’s consider our game. When you reveal a tile, the whole game is rendered over again. However, thanks to our immutable data model, all the tiles that didn’t change will still be the same exact references. These don’t need to be re-rendered, because with immutable data, same reference means no change. To let React know about this detail, we can improve our component wrapper as follows:
Scoop.it!
Minifying code is essentially the process of stripping away everything unnecessary: everything is condensed onto a single line, files are concatenated together, variables are renamed to be shorter and so on. There’s two main reasons you might want to do this:
Ionic has no automated process to do this but it’s relatively simple to set up your own process using Gulpand Grunt. A lot of this is based off of this tutorial by Agustin Haller which was tremendously helpful to me. The only problem I had with it though is that it relies on cordova hooks, and if you’re using PhoneGap Build to build your application then you won’t be able to use these.
Scoop.it!
From
scotch
This is the first of a five-part series on building a Slack clone using Meteor. The aim of these tutorials are not just for you to blindly follow instructures, but it’s our hope that you’ll understand the thought process and reasoning behind the architecture. Installation Installation is simple, just run the shell script Meteor prepared […]
Scoop.it!
In this blog post I will talk about the three core concepts of Angular 2: components, dependency injection, and property bindings. Disclaimer Angular 2 is still in the works. The core concepts are solid, but the API may change.
Scoop.it!
So, I went back and asked why Firebase and why are you fitting Firebase in your application architecture? Here are 2 major answers
After giving the above reasons a good thought, I have come up with the below architecture that will “emulate” Firebase using Websockets and Local Storage inside a Node.js/MongoD. If this solution gets stable over a period of time, I may create a yeoman/slush generator to scaffold a Node.js/Express.js and a MongoDB app with real time data sync and offline storage capabilities. For this post, I will use a simple Todo app as an example.
|
