23: Web Animation & Interaction Design
Direct download: episode-23_web-animation-and-interaction-design.mp3
Category:web-animation -- posted at: 7:09am EST
Comments[1]

22: LIVE - An Open Source Discussion Panel

A discussion on Open Source technologies with open source contributors & interested developers. We tackle topics such as how to get started contributing, resources that developers might need, starting a project of your own, understanding licenses, monetization strategies, and the darker sides of open source.

 

Our panelists:

 

This episode is also available on our YouTube channel

Links

Gitter - https://gitter.im/

Direct download: episode-22_an-open-source-development-panel.mp3
Category:open-source -- posted at: 9:39am EST
Comments[0]

21 : The X-Tag Project

Daniel Buchner (@csuwildcat), Product Manager at Target & former Mozillian, talks with The Web Platform Podcast on x-tag, the Custom Elements library competitor to Polymer that he created alongside former Mozillian & Kraken Developer, Arron Schaar (@pennyfx). X-tag is a interesting way to work with web components that takes a totally imperative approach to creating Web Components as opposed to the declarative way of building with Polymer. Some features include legacy browser support, optional mixins to share across components, & functional pseudos to assist in delegation.

 

Daniel has worked on the W3C specs for Web Components and is now updating x-tag to meet the demands of developers to have more flexibility with Shadow DOM, Templates, and HTML Imports. Daniel is very active on github and would love to have more contributors help build the future of the x-tag projects as well as all projects that help make the web better.

Resources

 

Direct download: episode-21_the-xtag-project.mp3
Category:web-components -- posted at: 2:59pm EST
Comments[0]

20: Mozilla Brick, ‘UIKit’ for The Web

Matt Claypotch (@potch), Mozilla Apps Engineer & Lead on Mozilla Brick Project and Soledad Penades(@supersole), GIF Hacktivist & Mozilla Apps Engineer, join us for Episode 20, “Mozilla Brick, ‘UIKit’ for The Web”, where we talk about building UI focused Web Components for the Mobile First Web Development.

 

Mozilla Brick is a set of ‘Mobile First’ focused Web Components built as close to the specs as possible. It is not a library built on top of web components but a collection of elements with as little abstraction as possible. Brick's goal has been to make building the interface of web applications easier. UI is not as easy for many developers to build from scratch and it can be difficult to get performant, usable, and attractive widgets.

 

“Just as native platforms have UI toolkits, Brick aims to provide a 'UIKit for the Web' using the latest standards to make authoring webapp UI easier than ever before.”

 

The Mozilla Brick Team

Resources

Firefox OS Marketplace example app - https://marketplace.firefox.com/app/firesea-irc?src=search

Direct download: episode-20-mozilla-brick-uikit-for-the-web.mp3
Category:web-components -- posted at: 9:40am EST
Comments[1]

19: Node.js Application Security

Chetan Karande (@karande_c), talks about Node.js App security and ways developers can prevent attacks. He goes into detail about working with Express.js in particular, NodeGoat, & his work with OWASP. Chetan is a team lead and senior software engineer at Omgeo and frequently speaks at conferences about JavaScript, Front End Technologies, Java, & Node.js.

Resources:

 

Direct download: episode-19_nodejs-application-security.mp3
Category:nodejs -- posted at: 3:59pm EST
Comments[0]

18: ORTC & WebRTC Deep Dive with Tsahi Levent-Levi

We covered the basics of WebRTC (Web Real Time Communication) & Real Time Application Development in episode 7 of the podcast with Agility Feat and now, with the recent news that Microsoft has decided to start implementing ORTC (Object Real Time Communication), we felt it was time to get a closer look at this ‘peer-to-peer’ technology and how we can start using it today. ORTC is an ‘evolution’ of WebRTC (AKA Web RTC 1.1) and it changes a few things to the underlying way Web RTC works. Despite this, ORTC seems to retain all of its previous API’s and functionality.

 

Our guest Tsahi Levent-Levi (@tsahil) goes through the API's associated with ORTC, sharing his experiences with each piece of the technology. He takes us through possible client strategies ,deployment 'gotchas', what is relevant and working today, the misconceptions, and the power of peer-to-peer communication & media interactivity.   

 

Resources

 

Direct download: episode-18_ortc-and-webrtc_deep-dive-with-tsahil-levent-levi.mp3
Category:realtime -- posted at: 8:19am EST
Comments[0]

17: The Famo.us vision of "Mobile First"

Defender of Magic, wizardry and the web, and CEO of Famo.us, Steve Newcomb (@stevenewcomb), walks us through the current state of Famo.us. Steve talks about how they are innovating the web and what we can expect in the future of “mobile first” web development from Famo.us.

 

Famo.us utilizes the power of a Virtual DOM combined with several engines that optimize the power of “cpu bound” performance. Famo.us claims to have mobile performance improvements that eliminate ‘janky’ animations and blur the lines between native device apps and mobile web apps.

 

Steve goes on to talk about how in April Famo.us will be releasing several features that will enable designers to easily pair with developers and also a new way of building with the framework that will “marry” native and web technology. “Mixed Mode” is a breakthrough for the team and apps built with this new feature will likely have native or even better than native UX & performance.

Resources

 

Direct download: episode-17_the-famous-vision-of-mobile-first.mp3
Category:JavaScript -- posted at: 9:59am EST
Comments[1]

16: Measures of Success in Pair Programming

Pair Programming is an agile software development technique in which two programmers work together on the same development work at the same time. Many variants exist for this practice, each having there own merits and drawbacks.

 

From a business perspective, many companies are skeptical and critical of this practice because it incurs cost. Whether that cost is measured by time or by labor hours, determining a measure of success for pair programming is not an easy thing to do. In a world where metrics and numbers define ‘the bottom line’ it is no surprise that pair programming is not used everywhere.

 

What does it provide for the business of product & software development? The benefits definitely outweigh the drawbacks from a developer perspective. Our Evan Light talks about the aspects of testing practices in pairing, tools, and many other secrets to unlocking the power pairing.

 

Evan Light (@elight) is a software developer with nearly 20 years of professional experience. Having a passion for community service, Evan has spent several years as a volunteer EMT. In 2008 Evan founded the Ruby DCamp “unconference” which he continues to organize and run each year. He is a respected member of the Ruby programming community and has spoken at several Ruby-related conferences over the years.

 

Evan has an extensive background in remote pair programming and recently spoke at RubyNation in Silver Springs, Maryland on the subject. Evan’s talk was titled “Remote Pairing From the Comfort of Your Own Shell” where he spoke about his challenges & experiences in pair programming over the years and what has tools he uses today.

Resources

eXtreme Programming Explained - http://www.amazon.com/Extreme-Programming-Explained-Embrace-Change/dp/0201616416

Pomodoro technique -

Agile Definition of Pair Programming -  http://en.wikipedia.org/wiki/Pair_programming

#PairWithMe - http://www.pairprogramwith.me/

Ruby DCamp - http://rubydcamp.org and http://evan.tiggerpalace.com/articles/2012/10/06/the-dcamp-manifesto/

Vagrant - https://www.vagrantup.com/

Tmux - http://tmux.sourceforge.net/

Tmate - http://tmate.io/

Vimux - https://github.com/benmills/vimux

My .emacs.d - https://github.com/elight/.emacs.d

Pomodoro Technique - http://en.wikipedia.org/wiki/Pomodoro_Technique

RubyMine - https://www.jetbrains.com/ruby/

Readme Driven Development - https://oncletom.io/talks/2014/okfestival/#/

J.B. Rainsberger “Integration Tests are a Scam” - http://vimeo.com/80533536

nitrous.io - https://www.nitrous.io/

Screen Hero - https://screenhero.com/

RubyNaition - http://www.rubynation.org/schedule/index

Pairing Staircase - http://itnaut.com/pairing_staircase

Evan on Twitter - https://twitter.com/elight: @elight

 

Evan’s Site - http://tripledogdare.net or http://evan.tiggerpalace.com

 

Direct download: episode-16_measures-of-success-in-pair-programing.mp3
Category:pair-programming -- posted at: 12:35am EST
Comments[0]

15: Functional Programming with Elm, ClojureScript, Om, and React

Episode 15 deep dives into the programming experiences of Adam Solove (@asolove), Head of Engineering at Pagemodo. Adam has spent the last ten years building web interfaces various technologies such as CGI, Flash, DHTML, RJS, jQuery, and many MVC JavaScript frameworks. Adam has found over his career that working with a more functional style of programming is much more rewarding in many ways.

 

Functional programming and FRP (Functional Reactive Programming) provides improvements in performance and purposely avoids changing-state and mutable data. This can be an extremely effective technique in web application development because of the stateful nature of DOM (Document Object Model) implementations in the browser. Adam evangelizes and works with several languages and tools to provide incredible functional style applications including, but not limited to, Elm, ClojureScript, OM, & React.js.

 

Facebook’s React.js, met with mixed reviews when it was first released in 2013.  Since then it has been stirring up support in droves within the JavaScript development community do to it’s high UI performance output in browsers. It’s Virtual DOM and ways of solving data & DOM performance problems have been highly criticized but hard to ignore. React has an effective unorthodox way of thinking about UI.

 

Elm, a functional reactive language for interactive applications, combines core features of functional languages like immutability & type inference with FRP to Create highly interactive applications without callbacks or shared state. Elm is similar in syntax to Haskell and it compiles to HTML, CSS, and JavaScript that uses a Virtual DOM model similar in concepts to that of react.js. According to Elm’s internal benchmarks, using it’s compiled JavaScript code is actually faster than any JavaScript framework tested by a extreme margin.  

 

ClojureScript, is a new compiler for Clojure that targets JavaScript. It is designed to emit JavaScript code which is compatible with the advanced compilation mode of the Google Closure optimizing compiler. David Nolen, has taken ClojureScript and created an interface for react.js called OM. Om allows for simple represention of Web Application User Interfaces as an EDN. ClojureScript data is immutable data, which means that Om can always rapidly re-render the UI from the root.  According to the project description, UIs created with Om are inherently able to create & manage historical snapshots with no implementation complexity and little overhead.

 

Resources

Elm

ClojureScript & OM

React.js

 

Comments[0]

14: Web Components Interop and Polymer

Today, Web Components have emerged from cutting edge technologies to technologies we can implement in our small scale production. It won’t be long before we are building large scale applications with Custom Elements, HTML Imports, Template Tags, and the infamous Shadow DOM. In embracing this type of developer environment, with it’s flexibility and compositional nature, consider interoperabilty as a core concept.

 

If you need a custom element for a card layout, as an example, you should be able to use any Web Component out there in the ecosystem regardless of which library or toolchain it comes from. If the component provides the desired functionality and styling you would require it should work seamlessly in your application. Furthermore, toolsets should not limit the the extending and composition of these custom elements. In practice, this may or may not always be the case and library & toolchain creators will need to be aware of these concerns.

 

Rob Dodson (@rob_dodson), Developer Advocate on the Google Chrome team, talks about his thoughts on the subject. Rob is helping to educate developers, not just about Google’s Polymer Library built on top of Web Components, but across the entire Web Components community.

 

Rob goes through many of the changes made to Polymer 0.4.2, including accessibility and performance that help in making applications more integrated and how Google is working to share what the Blink Team has learned from implementing Web Components in Chrome with other browser vendors and developers.

 

Working closely with Mozilla developers on his SFHTML 5 Meetup talk on Web Components Mashups, Rob was able to collaborate and share ideas so that Web Components could alleviate many of the concerns we had when migrating from one JavaScript library to another. It is painful for developers to have to remake components every time they switch libraries or frameworks. Web Components aims to make that a thing of the past and Rob has done much more on this topic since that talk. Have a listen and hear what he has to say.

Resources

Rob’s Blog - http://robdodson.me/

I/O Presentation - http://webcomponents.org/presentations/unlock-the-next-era-of-ui-development-with-polymer-at-io/

Accessible Web Components Part 1 -https://www.polymer-project.org/articles/accessible-web-components.html

SFHTML Mashup Video -https://www.youtube.com/watch?v=75EuHl6CSTo

The Web Platform Status for IE - https://status.modern.ie/

IE Beta Channel - http://www.microsoft.com/en-us/download/details.aspx?id=43360

Polytechnic Events - http://itshackademic.com/

Polycast Playlist - https://www.youtube.com/playlist?list=PLOU2XLYxmsII5c3Mgw6fNYCzaWrsM3sMN

Custom Elements on GitHub - https://twitter.com/polymer/status/464103568392200193

IE Platform Voting -https://wpdev.uservoice.com/forums/257854-internet-explorer-platform

customelements.io - http://customelements.io/

Webcomponents.org -http://webcomponents.org/

Bosonic Shadow DOM Issue (#4) - https://github.com/bosonic/bosonic/issues/4

The Bower Package Manager - http://bower.io/

Divshot - http://divshot.io

Divshot Blog - https://divshot.com/blog/

BuiltWithPolymer - http://builtwithpolymer.org/

Divshot’s Web Component Playground - https://ele.io/

Angular 2 Web Components Data Binding Document - https://docs.google.com/document/d/1kpuR512G1b0D8egl9245OHaG0cFh0ST0ekhD_g8sxtI/edit?hl=en&forcehl=1&pli=1#heading=h.xgjl2srtytjt

ReadTheSource - http://hangouts.readthesource.io/hangouts/divshot-superstatic/

RailsCasts -http://railscasts.com/

PhantomJS -https://github.com/ariya/phantomjs/wiki/PhantomJS-2

saucelabs -https://saucelabs.com/

People

Alex Russel -https://twitter.com/slightlylate

Alice Boxhall -https://twitter.com/sundress

Raphael Rugeron - https://twitter.com/goldoraf

Jonathon Sampson  -https://twitter.com/jonathansampson

Arron Schaar - https://github.com/pennyfx

Michael Bleigh - https://twitter.com/mbleigh

Scott Corgan - https://twitter.com/scottcorgan

Projects

Reactive Elements -https://github.com/PixelsCommander/ReactiveElements

X-Tags Imports - https://github.com/x-tag/x-tag-imports

Enyo -http://enyojs.com/

React.js -http://facebook.github.io/react/

Famo.us -http://famo.us/

Chromium Blink -http://www.chromium.org/blink

Polymer 0.4.2 -https://github.com/Polymer/polymer/releases/tag/0.4.2

Brick 2.0 -http://brick.mozilla.io/

X-Tags -http://www.x-tags.org/

Polymer -https://www.polymer-project.org/

Bosonic -https://bosonic.github.io/

Vulcanize - https://github.com/polymer/vulcanize

generator-element -https://github.com/webcomponents/generator-element

Firefox OS - https://www.mozilla.org/en-US/firefox/os/

web-component-tester -https://github.com/Polymer/web-component-tester

Topeka -https://github.com/polymer/topeka

Jquery UI -http://jqueryui.com/

Components

core-a11ykeys -https://github.com/Polymer/core-a11y-keys

core-list -https://github.com/Polymer/core-list

core-animated-pages -https://github.com/Polymer/core-animated-pages

Brick Components -http://brick.mozilla.io/v2.0/docs

WinJS Polymer Samples -https://github.com/banguero/winjs-polymer-samples

core-ajax - https://github.com/polymer/core-ajax

google-map - https://github.com/GoogleWebComponents/google-map

core-shared-lib - https://github.com/Polymer/core-shared-lib

google-apis - https://github.com/GoogleWebComponents/google-apis

core-selector - https://github.com/polymer/core-selector

paper-menu-button - https://github.com/Polymer/paper-menu-button

paper-tabs - https://github.com/Polymer/paper-tabs

paper-elements - https://www.polymer-project.org/docs/elements/paper-elements.html

core-signals -https://github.com/Polymer/core-signals

Direct download: episode-14_web-components-interop-and-polymer.mp3
Category:web-components -- posted at: 11:44am EST
Comments[2]