Advanced JavaScript [repost]

Advanced JavaScript
2.57GB | Duration: 6h 55m | Video: AVC (.mp4) 1024×768 24fps | Audio: AAC 44.1KHz 2ch
Genre: eLearning | Level: Intermediate | Language: English

Gain an advanced understanding of the core mechanics of how JavaScript compiles, optimizes, and executes in the browser.

Kyle Simpson, author of the “You Don’t Know JavaScript” book series, details the inner workings of JavaScript in extreme detail. Gain an advanced understanding of the core mechanics of how JavaScript compiles, optimizes, and executes in the browser. This is your chance to get an “under the hood” intimate working knowledge of JavaScript.

Reactive Programming with RxJS: Untangle Your Asynchronous JavaScript Code

Reactive Programming with RxJS: Untangle Your Asynchronous JavaScript Code by Sergi Mansilla
English | 2015 | ISBN: 1680501291 | 140 pages | PDF | 3,7 MB

Reactive programming is revolutionary. It makes asynchronous programming cleaner, intuitive, and robust. Discover how to use the RxJS library to write programs in a simpler way, unifying asynchronous mechanisms such as callbacks and promises into a single, powerful construct. Learn to think about your programs as streams of data that you can transform by expressing what should happen, instead of having to painstakingly program how it should happen. You’ll be able to handle real-world concurrency and write complex flows of events in your applications with ease.

Create highly concurrent applications while writing simpler code using the Reactive Extensions for JavaScript (RxJS), a set of libraries for event composition. Programming real-world applications in JavaScript involves lots of asynchronous events–you might end up spending more time coordinating asynchronous code in your program than writing its actual functionality. This book introduces concepts and tools from reactive programming that will help you write cleaner and more robust asynchronous programs.

Find out about Observable sequences, a unifying data type to write highly concurrent code. Discover Schedulers and change the concept of time in your applications, making asynchronous testing sane again. Along the way you’ll see real-world examples for the browser and Node.js, including a real-time earthquake visualization in 20 lines of code and a frantic shoot-‘em-up space videogame. You’ll also use Cycle.js – a modern, fully reactive web framework – to make a whole new breed of web applications.

By the end of the book, you’ll know how to apply reactive programming to solve complex problems, build efficient programs with reactive user interfaces, and write your code more declaratively.

What You Need:

A modern web browser, Node.JS installed in your computer, and the RxJS JavaScript library.

Moodle JavaScript Cookbook [Repost]

Moodle JavaScript Cookbook by Alastair Hole
English | Apr. 26, 2011 | ISBN: 184951190X | 180 Pages | PDF | 2 MB

Make Moodle e-learning even more dynamic by learning to customize using JavaScript. With over 50 recipes, this Cookbook allows you to add effects, modify forms, include animations, and much more for an enhanced user experience.

Сюрреализм на JavaScript

Сюрреализм на JavaScript – Бахирев А.М.
2014 | ISBN: 5990566077 | PDF | 228 pages | 28 Mb

Книга о разработке игр и приложений на Javascript. В книге встречается множество отсылок к авторам различных публикаций и экспертам фронтенд-разработки. Также затрагивается тема кроссплатформенной разработки на javascript для различных устройств, XSS атаки, обфуская кода, и конвертирования HTML в EXE, НТА, СНМ и т.п. Эта книга рассчитана, в основном, на опытных веб-разработчиков, которые делают сайты не один год.

Let"s Code JavaScript - The Lab

Let’s Code JavaScript – The Lab
HDRips | MP4/AVC, ~1001 kb/s | 1280×720 | Duration: 13:07:41 | English: AAC, 66 kb/s (1 ch) | 7.41 GB
Genre: Development / Programming

Experimentation, exploration, and general messin’ about. Here in The Lab, we try out new tools, create new ideas, and see what we can break. Anything and everything that doesn’t fit in the other channels could end up here.

Front-End Frameworks: Ember.js (Part III)

We wrap up our exploration of Ember.js by building out custom form fields, setting up events and cross-application communication mechanisms, and dealing with performance. In the end, is Ember.js a good choice for your front-end applications? We decide.

Front-End Frameworks: Ember.js (Part II)

We continue our investigation of Ember.js with a look at its influence on design and architecture. We build out our stock market projection components and hook them up to our intentionally-quirky domain layer. How easily does Ember integrate with existing business logic, and what does it take to test an Ember component? We find out.

Front-End Frameworks: Ember.js (Part I)

Ember.js is a framework for, in their words, “ambitious web applications.” But is it going to cause more trouble than it’s worth? We start a three-part deep-dive into Ember. In this episode, Ember fundamentals. We look at a “Hello World” app, components, modularity, testing, and the challenges of escaping Ember’s assumptions.

Front-End Frameworks: AngularJS (Part III)

We conclude our investigation into AngularJS’s impact on design and architecture. In this episode, we bring in our pre-existing persistence layer and use it to coordinate changes across our application. We also create a custom form field that uses domain-driven validation. Does AngularJS play well with our architecture? Should you use it? We render our verdict.

Front-End Frameworks: AngularJS (Part II)

We continue our exploration of AngularJS with a look at application design and architecture. Angular assumes simple models that live in “scope” objects. Our sample application, though, has a rich domain layer based on Ward Cunningham’s CHECKS pattern language. How well does Angular handle an approach that’s outside its comfort zone? We investigate.

Front-End Frameworks: AngularJS (Part I)

AngularJS is a hugely-popular framework for web applications from Google. It’s known for its two-way binding and automatic dependency injection. But does it live up to our standards of maintainability and long-term reliability? We take a close look in this three-part series. First: AngularJS fundamentals, including controllers, directives, modularity, and testing.

Quixote: CSS Unit Testing

On the Recorded Live channel, we’ve been working on a proof-of-concept suite of CSS unit tests. The concept’s been proven. Now it’s time to turn that work into a general-purpose open source library: Quixote. I’m conducting a virtual hackathon October 13-16 starting at 10am PDT (GMT-7) to build the library. Join us!

Front-End Frameworks: React (Part II)

We conclude our look at React, the front-end library from Facebook. In this part, we investigate React’s architecture and design constraints by building a real app. How well does React deal with architectural approaches that it wasn’t designed for? How does it coordinate far-flung components? What about lock-in, complexity, and testing? We answer it all.

Front-End Frameworks: React (Part I)

React is the hot new library for building user interfaces from Facebook. It boasts an innovative virtual DOM and bucks the trend by eschewing templates. How well does it work for real-world apps? We dive deep with a two-part series. In this first episode, we get React up and running and look at the fundamentals of automation, modularity, and testing.

Legacy Code Part IV: Unit Tests

The conclusion of our four-part legacy code series! We’re ready to put unit tests in place for Intro.js, our real-world legacy code example. We extract our scrolling function into its own module, install Karma, and implement honest-to-goodness cross-browser unit tests around it. Challenge completed!

Legacy Code Part III: Refactoring

Our massive legacy code series continues! With pinning tests in place, we can safely change our legacy Intro.js code. We need to do two things: figure out how the showElement() function works and set the stage for introducing unit tests. To do that, we’ll factor showElement() into its component pieces.

Legacy Code Part II: Pinning Tests

We continue our series on testing and refactoring legacy code. Now that we understand the design of Intro.js and know what we want to change, we need a way to refactor the code safely. Our centerpiece will be pinning tests: rough tests that warn us when we accidentally change the behavior of our legacy code.

Legacy Code Part I: Reflective Design

Legacy code. It’s a problem everyone must face at some point in their career. What do you do when you inherit a codebase that you don’t understand? How do you add tests to existing code? Today in The Lab, we start a massive four-part series on testing legacy code. First up: reverse-engineering the design of existing code and creating a test strategy.

CasperJS

We’ve used PhantomJS, the headless web browser, to automate our smoke tests. PhantomJS is fairly low-level, however, which makes writing tests pretty painful. Enter CasperJS. CasperJS is a wrapper that promises to make PhantomJS much more convenient. Today in The Lab, we put it to the test. How does CasperJS work, and will it live up to its promise?

Test Them Test’em

For months, we’ve been using Karma for cross-browser testing, but I’ve also heard great things about Test’em ’Scripts. Today in The Lab, we put it to the test. Can Test’em supplant Karma as our test runner of choice? Or will our needs prove to be too much?

Simplebuild It and They Will Come

Confession time: I don’t like frameworks. Sure, they’re powerful and convenient, but they lock you in. Grunt’s plugins are a typical example: powerful task automation, but you have to use Grunt. Is there another way? Today in The Lab, we find out. Our challenge: Create an approach to task automation that’s as convenient as Grunt’s, without the lock-in.

Vojta Jína on Karma, AngularJS, and More

Today in The Lab, a special treat: Vojta Jína, the creator of Karma, joins us for a wide-ranging discussion about the origins of Karma, the $ 10,000 bet that made AngularJS a success, and his secret life as a trumpet player.

The Great Grunt Shootout

Nearly since the beginning, viewers have asked why I use Jake instead of Grunt for automated builds. I had my reasons, but now it’s time to find out if those reasons are valid. Does Grunt really hurt long-term maintainability in favor of short-term ease-of-use, as I fear? Or am I just paranoid? We’re off to The Lab to find out.

Other Development / Programming lessons:

screenshot

Welcome to the best eLearning video (English, German, French, Spanish language) and many more: LINKDo not forget to check my blog! Updated regularly! Add in bookmarks my blog PM me if Links not working!

No mirrors pls!

Let"s Code JavaScript - Lessons Learned

Let’s Code JavaScript – Lessons Learned
HDRips | MP4/AVC, ~1951 kb/s | 1280×720 | Duration: 05:07:32 | English: AAC, 96 kb/s (1 ch) | 3.64 GB
Genre: Development / Programming

A concise reference. The Lessons Learned channel distills out what we learn from the main series. Each episode explains the theory and practice of a specific topic. They’re great for reference, review, or just catching up.

Lint & JavaScript

In this early screen test for Let’s Code TDJS, we look at what linting is, how to use it, and how to incorporate it into your automated build.

Continuous Integration with Git

We review version control fundamentals and how they apply to Git, then look at what continuous integration is and how it’s often misunderstood. Next, we look at how to make continuous integration work with Git and a team of multiple developers. We close with a handy utility to make it easier to use continuous integration on your team.

Test-Driven Development with NodeUnit

We talk about what test-driven development is and why it works, then take a look at Node.js basics. Next, we tie the concepts together and test-drive a simple Node.js module. Finally, I share some code for running NodeUnit in a Jakefile or other JavaScript program.

Integration Testing a Node.js Web Server

We look at what integration testing is, how it’s different from unit testing, and why and when it’s useful. Next, we take a brief look at Node server fundamentals. Finally, we tie it together by using integration tests and test-driven development to create a simple Node.js web server from scratch.

Smoke Testing a Node.js Web Server

We look at what smoke testing is, the unique spot it occupies in the TDD ecosystem, and when—and when not—to use it. Next, we have a refresher on the basic Unix process model and how to work with processes in Node. Finally, we tie it all together by writing a basic smoke test for our WeeWikiPaint server.

Deploying a Node.js Web Server to Heroku

We discuss what Heroku is and how to deploy an application to Heroku, then apply the concepts to deploying our WeeWikiPaint application. We close with a convenient automated deployment script you can use on your own projects.

Cross-Browser Testing with Karma

We look at the unfortunately-named Testacular tool (since renamed to Karma) and how to use it. We create a simple test and run it across multiple browsers and platforms, then close with an automated script for running Testacular.

Unit Testing DOM Manipulation Code

We look at the essential components of a unit test and how they change when you’re testing the DOM. Then we demonstrate those ideas by building a simple DOM test from scratch.

Automatopia

We look back at everything we’ve done so far and tie it into a cohesive suite of automation tools that you can use to get a jump-start on your own test-driven JavaScript development.

Unit Test Strategies, Mock Objects, and Raphaël

It’s easy to test pure functions and stateful objects. But testing functions with side effects is much harder. We look at three strategies for testing side effects: Asking; Inspecting; and Injecting. We demonstrate the strategies with Raphaël, the vector graphics library, and discuss when to use each one.

DOM Events, UI Testing Strategies, and Selenium

Let’s say you want to write some simple client-side form validation code. How do you test it? In this episode, we take a close look at DOM Events, then consider three strategies for testing UIs: Robots (such as Selenium), Simulation, and Thin UIs. We demonstrate the strategies in code and discuss the tradeoffs of each approach.

Front-End Unit Testing in a Nutshell

In recent videos, we’ve spent a lot of time on front-end testing. But how does it all tie together? What, exactly, should you do when test-driving front-end code? If you’ve been hoping for someone to just lay it all out for you, I have good news: this one’s for you.

Definitive Guide to Object-Oriented JavaScript

If you hang around the JavaScript world long enough, you’ll come across a bunch of different recipes for object-oriented programming. The “standard way,” so much as there can be a standard way, is the classical model. But why this? Why this… mess? In this episode, we’ll build it up from first principles.

PhantomJS and Front-End Smoke Testing

Sometimes, unit tests aren’t enough. Sometimes, you need to make sure your code works when loaded in a real browser by a user. But how do you do that? In this episode, we look at how you can use PhantomJS to test your code end-to-end.

Front-End Modules

Once a program gets past a certain size, it’s no longer practical to store everything in a single file. So what do you do when your code outgrows your editor? How can you create maintainable, modular front-end code in JavaScript? In this episode, we take a look at three options: namespaces, AMD, and CommonJS.

Large-Scale JavaScript Fundamentals

In recent episodes, we’ve spent a lot of time and effort on getting Karma to work with CommonJS modules. But why bother? What’s the point of going to all that work, when it’s so much easier to just load a test page in the browser? We look at getting the fundamentals right.

JavaScript Workflow 2015

Everything you need for a great development environment in 2015 and beyond. This episode brings all my front-end workflow recommendations together into a complete package that’s updated with my latest recommendations. Topics include reproducible builds, continuous integration, linting, front-end modules, and cross-browser testing.

Other Development / Programming lessons:

screenshot
3948949
3948950

Welcome to the best eLearning video (English, German, French, Spanish language) and many more: LINKDo not forget to check my blog! Updated regularly! Add in bookmarks my blog PM me if Links not working!

No mirrors pls!