Free Webinar: Introduction to Parallel Testing With JUnit, Selenium & Sauce Labs

Registration is now open for our (first!) upcoming webinar, Introduction to Parallel Testing With JUnit, Selenium & Sauce Labs on Jun 6, 2013 10:00 AM PDT. 

Register Now!

At Dynacron Group, we love to solve complex challenges, and we love learning new technology while doing it! One of the biggest challenges today is managing the explosion of test cases which must be executed repetitively as a result of combinatorial test factors. Some of these factors include... 

• Multiple browsers (varying by version, operating system, desktop & mobile) 
• Self-updating browsers 
  
• Multiple languages & locales 
  
• Different branding on similar sites 

It's easy for all of these factors to result in an explosion of testable combinations. How do you describe these combinations, queue them for execution, and link them to test results in your continuous integration server? How do you design it to be extensible and maintainable? 

In this presentation, we will discuss our real world techniques for combinatorial testing with Selenium and JUnit, leveraging on-demand resources from Sauce Labs. We will describe successes and challenges encountered along the way. We will discuss concrete problems (and solutions) encountered in Selenium framework design for both a major retailer with multiple simultaneous brand launches, and performance testing involved in the successful launch of a new consumer device used by millions. 

Speakers: 

David Drake, Lead Software Developer in Test (SDET) 
Keith Bloomfield, Senior Java Developer

After registering, you will receive a confirmation email containing information about joining the webinar.

Introduction to Big Data Seminar Now Online

In case you missed our event last week, here is the video recording of the Introduction to Big Data seminar we did last week.

Hope you can catch us for our Introduction to Continuous Delivery seminar on Thursday this week!

Should I Automate That?

Here's a nice little chart, courtesy of xkcd, to help you decide if it is worth the time to automate it:

Free Seminar: Introduction to Big Data Thursday, April 25, 2013

At Dynacron Group, we love to solve complex challenges, and we love learning new technology while doing it! As it becomes easier and cheaper to collect large volumes of data, technology is evolving to allow us to query and analyze the data.

Do these problems sound familiar?

• Data volume is in terabytes, and we are having trouble storing/accessing it
• We can store terabytes of data, but we have no way to analyze it in a reasonable timeframe
• We have a database with billions of records, and need a 12-table join in real-time to get an answer for a webpage, but it brings the whole system down
• We need to support thousands of writes per second, or tens of thousands of reads per second, with latency under 10ms.

In this presentation, we will take a whirlwind tour of Big Data as an abstract concept that’s been popularized over the past several years. We will explore some use cases where Big Data helps deliver value, and also talk about where it might not be the right solution.

After the general overview, we will go into some detail on several different packages that we have used ourselves. Choosing the right package is critical to getting the most for your investment, and we will explore the strengths, weaknesses, and our work in:

• MongoDB
• Cassandra
• Neo4j

Dynacron Group has deployed these systems with terabytes of data, billions of data points, and tested them for scalability, latency, throughput, and availability. Not only will we share some of our experiences with you, but we will also share some of our experiences when it comes to the challenges of IT teams, developers, staffing, and selling the rest of your team. We will show you how you can ease your company’s data into the future, and how Dynacron Group can help you do it.

Register Now: http://seattle-big-data.eventbrite.com/

Introduction to Continuous Delivery: May 2nd, 2013

Come join us for a free seminar:

Introduction to Continuous Delivery!

Thursday, May 2, 2013 from 3:00 PM to 5:00 PM (PDT)
Kirkland, WA

Continuous Delivery refers to the process of releasing high quality software quickly and with confidence through the use of build, test and deployment automation. By applying Lean techniques to the development, test and deployment of software, waste is reduced and staff are freed up to work on more important tasks. By following a continuous delivery model, release cycles shift from a matter of months to weeks or days.

In this presentation, we will look at the key tools and processes involved in transitioning from a manual culture to one that embraces automation. We will look at real world examples, including the tools and architectural components. We will discuss organizational impacts, including the dramatic improvements in morale as team delivery commitments are met more easily through automation.

More information and registration at http://cd-intro.eventbrite.com/

Promises, Promises

A frequent topic for developers (particularly in JavaScript) is "promises." Put simply, it's another way to tackle asynchronous programming.  Asynchronous programming is kind of a Big Deal - it's important for end user applications because users want to do keep doing things (e.g. reading email) while waiting for things to happen (e.g. downloading more email).  It's also a really big deal for server applications - obviously, a server needs to be able to handle lots of users, but that server also may be doing things (e.g. checking three different database systems) that would be a lot faster asynchronously.  Oh, and as we add more and more cores instead of just making faster chips, software runs faster everywhere if it can take advantage of those cores.  That affects EVERYTHING - from your phone, to your gaming console, to your laptop.

One minor detail: asynchronous programming has traditionally been a giant pain.

So, with that in mind, here's a very nice introduction to JavaScript promises.

For comparison, check out Akka, the REST client stack in DropWizard, the jQuery promise, and the Java 7 fork/join.

What other asynchronous programming models have you seen or used?  And for bonus points: how do you test and debug async code?

Building on Top of JavaScript

JavaScript is not going away. If you're a fan of the language or not, it's still the de-facto user interface language of world-scale development. We've seen attempts to supplant it fall by the wayside (e.g. Flash and Silverlight). Now things seem to be going the other way - treating JavaScript as a runtime. These solutions involve translating a higher-level language into plain-old JavaScript - usually on the server, for performance. For now, I'd just like to talk about CoffeeScript - and maybe follow up on Dart and TypeScript later. Disclaimer: I really like CoffeeScript - it removes a lot of the rough edges from a decent (if spartan) language.

CoffeeScript:

The code compiles one-to-one into the equivalent JS, and there is no interpretation at runtime. You can use any existing JavaScript library seamlessly from CoffeeScript (and vice-versa). The compiled output is readable and pretty-printed, passes through JavaScript Lint without warnings, will work in every JavaScript runtime, and tends to run as fast or faster than the equivalent handwritten JavaScript.

The thing that draws me to CoffeeScript is that it's not a whole new language with new paradigms on how to use it - it really is just JS, just not as ugly. It's white-space significant (which I've grown to like). "It's Just Javascript", so resulting JavaScript is pretty easy to mentally map to the source CoffeeScript while debugging. There are a lot of features like Classes, arrow operators replacing the 'function' key word, Loop Comprehensions (do you miss LINQ? think underscore), and a host of other useful things.

Where can you use CoffeeScript, and how? To learn about the language head to http://coffeescript.org. Then you can practice your chops at http://jsfiddle.net. I find http://js2coffee.org very nice for going back and forth between CS and JS.

When you're ready to start using CS in your app, there are a couple of options. If you're using Node.js - it's already built in! .

For Visual Studio, just grab the free Web Essentials extensions for 2012 or 2010. It allows you to edit CoffeeScript (in addition to some other interesting stuff).

It seems that most Web Development environments support it in one way or another - here's a plugin for Eclipse.

Next, I'll go over the other two (which are not "just JavaScript") - they bring heavier OOP concepts to the table.

Where do you stand on CoffeScript or compile-to-JS languages in general?

Front End Development

A long time ago, the "action" was on the server-side, with technologies like Struts, EJB, Hibernate, and Spring.  Lately, I'm seeing a lot more movement on the front-end - mobile devices, HTML5, and the increasingly ubiquitous JavaScript.  That dynamism and energy is translating into the back-end, with services like Mongo using JavaScript and JSON as primary interfaces. From a complexity standpoint, it's easy to see how the requirements (in particular, for mobile devices) are driving things.  When Steve Jobs decided to drop Flash, the only way to deliver content to iOS devices without going through the App Store was mobile Safari, and that means HTML+JavaScript.  Throw in the fantastic performance of Chrome's JavaScript engine, breaking out the JavaScript engine into Node.js, and you can see the evolutionary tree taking shape.

Right now, the biggest challenge with JavaScript is the incredible array of options.  Angular, Backbone, Ember, Knockout, and who knows how many more.  We've been experimenting will all of them (Ember is an early fav right now).

As an example of the complexity, check out this blog on building a responsive, Retina-aware interface.  Many (most?) of the tools listed didn't exist a year or two ago.

3D, location, cameras, touch interfaces - things are going to change a lot over the next few years.

Cool, huh?

Threading. Problems.

Davidlohr Bueso ‏@davidlohr

A programmer had a problem. He thought to himself, "I know, I'll solve it with threads!". has Now problems. two he

Don’t Reinvent the REST/JSON Wheel

Working on a REST/JSON web service?  No need to reinvent the wheel - there are several nice packages to get started. One that we've had tremendous success with is Dropwizard.  Java-based, ops-friendly, very fast and easy to get started.

Another interesting package is Swagger. For larger projects, documentation and self-describing services become more and more important.  One nice thing about Swagger: quick, fast bootstrap for everything - Spring, Play, Scala to Node.js, and many more.

As we see more and more web applications looking more and more like REST/JSON services feeding JavaScript applications, this kind of development model becomes more and more appealing - even more so with such easy tools.