Building Maintainable Software, C# Edition: Ten Guidelines for Future-Proof Code

Duane"s Ophthalmology Solution, Online Access Code

Duane’s Ophthalmology Solution, Online Access Code by William Tasman MD and Edward A. Jaeger MD
English | 2006 | ISBN: 0781768551 | 485 pages | CHM | 630 MB

Click here to view a narrated demo to see all the features of the completely online version of Duane’s Ophthalmology!

The vast information stored in this classic reference is right at your fingertips with this fully searchable online version. This easy-to-navigate Website gives you instant access to the latest surgical techniques and treatments for primary open angle glaucoma, retinal detachment, ocular hypertension, and more. And you’ll manage every eye problem, large and small, with confidence.

In addition to the entire contents of Duane’s Ophthalmology, your two-year subscription to the Website features:

A wide range of searching capabilities enabling you to search by key word, phrase, combination, topic, chapter subject or contributor

All the images from Duane’s, searchable and downloadable for use in presentations

State-of-the-art video from the Wills Eye Video Atlas of Ocular Surgery, the first comprehensive video atlas of basic and advanced surgical procedures in all ophthalmic subspecialties

A test bank featuring multiple-choice and true/false questions with answers and explanations

Quarterly updates to the core content of Duane’s provided by the authors to keep you up-to-date with the latest procedures and treatment options

Free full-text articles posted each month from leading ophthalmology journals including Cornea, Current Opinion in Ophthalmology, Evidence-Based Ophthalmology, Journal of Glaucoma, Techniques in Ophthalmology, and International Ophthalmology Clinics

In addition to the quarterly updates to the core content of Duane’s, the Website will add new videos, new test questions, and more throughout your entire two-year subscription. It’s still the Duane’s Ophthalmology you have trusted for over 30 years, but we are no longer providing you with a CD-ROM that can’t be updated. With Duane’s Ophthalmology being fully online, we can better serve your needs by providing you with the most up-to-date information every time you access the site!

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.

eBook for Microeconomics, 20E, With Access Code For Connect Plus [Repost]

Microeconomics: Principles, Problems, & Policies (McGraw-Hill Series in Economics) by Campbell R Mcconnell
English | 1 Mar. 2014 | ISBN: 0077660811 | 672 Pages | PDF (True) | 10.53 MB

McConnell/Brue/Flynn has long set the standard for providing high-quality content to instructors and students all over the world. It has remained the most widely used principles of economics product as a result of persistent innovation. The 19th edition brought adaptive technology to the market for the first time with LearnSmart, a resource that ensures that every minute a student spends studying is the most efficient and productive time possible. Feedback from users in combination with the analysis of student performance data from the 19th edition’s digital products significantly informed the revision of the 20th edition, resulting in a product expertly tailored to the needs of today’s students.

With the 20th edition, students and instructors will benefit from a new offering that expands upon the dynamic and superadaptive capabilities of LearnSmart: SmartBook, the first and only adaptive eBook. McConnell/Brue/Flynn’s tradition of innovation continues with the 20th edition, providing market-leading content and digital mastery to benefit today’s learners.

Connect is the only integrated learning system that empowers students by continuously adapting to deliver precisely what they need, when they need it, and how they need it, so that your class time is more engaging and effective.

CODE Magazine - May-June 2016

CODE Magazine – May-June 2016
English | 76 pages | True PDF | 9 MB

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!