It’s time for another Tuesday Bi-weekly Review! We’ve been making some progress and so far we’ve tackled a few elements of the project. The first big task was to get more information out there for the community & team working on the project. I’ve spent some time along with the contributors on github and via other means to make more information available to what the intent is and how people can contribute. So if you’re interested in helping with an entire domain space or merely a small element of the application, ping me and I’ll work with you to make it as easy as possible to contribute. With that, let’s jump into what’s what and what’s new. Cheers!

We Have a Build Server, More on This Soon, but for now…

I’ll have a post on how to setup Team City and quick tour of what is setup for the Junction Project. So stay tuned and I’ll have that and other news posted as it happens this coming week along with Team City & other tutorials related to the project itself. For a quick sneak peek feel free to take a look at the build server located at:  http://teamcity.cascadiahacks.org/.  Just login with “guest” and no password.

More Items Listed and Working on First Feature Commits and Comments For…

We also got a conversation started among a few of us “What would teams that use Riak like to see in a Riak Admin Application?” Jump into and add your two cents regardless of whether you’re diving into the project or not.

Until later, happy coding!

I’ve got two presentations happening this year at Seattle Code Camp! Are you signed up? If not, hit this and get signed up ASAP:  https://seattlecodecamp2013.eventbrite.com/

My two presentations are:

Distributed Databases – An Introduction to Riak

Presenter:Adron Hall

I’ll dive in with a quick definition and context of what distributed databases are. From there we’ll quickly move into what Riak is, how its architecture lends it toward being one of the premier distributed database solutions on the market today. We’ll take a walk through vector clocks to consistent hashs, clusters and rings managing the world of the distributed systems. Then we’ll dive into a use case with a put and pull of data from a walkthrough implementation of Riak.

…and…

Developer Workflow: From Angular.js, Riak, Testing and Vagrant Dev Environments

Presenter:Adron Hall

Each developer has to come up with a workflow that works well for them. Sometimes a lot of the workflow is dictated but there is still a lot that’s left up to the individual. With many modern tools you have a selection of everything from text editor, to IDE to actual operating system distribution. In this presentation I’m going to walk through some of the tooling to help keep all of these things under control during the course of programming efforts. …and yes, this will go beyond just the IDE (or text editor, etc)

…and others to check out!

Much Ado About Hadoop

Presenter:Jeremiah Peschka

By now you’ve heard the words “Big Data” and “Hadoop”, but you’re not sure what they mean, much less how to get started. You’re struggling with storing a lot of data, rapidly processing a huge volume of data, or maybe you’re just curious. There are a bewildering array of options and use cases within the Hadoop ecosystem. Every day I help customers understand their data problems, understand where Hadoop fits into their environment, and determine how they can use Hadoop to solve their problem. This session provides an introduction to what Hadoop is, when it’s appropriate to use Hadoop, and guidance on how to get started.

Unit Testing Web Development

Presenter:Mark Michaelis

When it comes to testing, Web Development is fraught with challenges whether it be from variations in browser behavior, the lack of compilation on JavaScript, or the traditional coupling between the UI and the code. In this session we walk through the complexities surrounding the testing of web projects and cover how to overcome these. This includes leveraging everything from source code analysis and JavaScript unit testing to UI and performance testing. Don’t miss this session to learn a multitude ways to significantly improve the quality of your web development.

Riak in a .NET World

Presenter:Jeremiah Peschka

Developers have a lot of choices when it comes to storing data. In this session, we’ll introduce .NET developers to Riak, a distributed key-value database. Through a combination of concepts and practical examples, attendees will learn when Riak might be appropriate, how to get started with Riak using CorrugatedIron (a full-featured .NET client for Riak), and how to solve data modeling problems they’re likely to encounter. This talk is for developers who are interested in backing their applications with a fault-tolerant, distributed database.

Introduction to Ember.js

Presenter:Jon Cortez

Ember.js is an open-source client-side JavaScript web application framework based on the Model-View-Controller (MVC) software architectural pattern. It is designed to help developers build scalable Single Page Applications (SPAs) by incorporating common idioms and best practices into a framework that provides a rich object model, declarative two-way data binding, computed properties, automatically-updating templates, and a router for managing application state. In this session, you will learn the key concepts of Ember.js and how to use it to create a simple Single Page Application.

Think Like a Dev: Cognitive Pitfalls in Software Development

Presenter:Michael Ibarra

Our own minds are often working against us. What makes estimating so hard? Is there real value in planning poker? How effective are weekly retrospectives, really? Let’s explore how our minds may be working against us in ways we might not realize. We’ll examine the sources of some common cognitive biases, how they apply to our work efforts, and discuss some “strategery” for overcoming them.

Building a Server Appliance in Node.js

Presenter:Eugenio Pace

Auth0 is a server/service to drastically simplify authentication, identity federation & SSO scenarios; for web & mobile apps. It’s our first big project on node. One of the reasons we decided to build it entirely on node, is the ability to package it and deploy it anywhere: as a service in the public cloud, as a virtual appliance on private cloud, or as an appliance on-premises. In this session we’ll show how we built it. How we use JS for extensibility and easy customization. What worked well, what didn’t. Tools we used, etc.

Hope to see you there. Cheers!

So every two weeks I intend to provide an update for the Junction Project. Who might have joined, what was worked on, where we are and generally any other bits of news related to the project. This is the first “Junction Two Weeks on Tuesday Review” so enjoy!  🙂

• Two weeks ago today I wrote the entry “Introducing Junction” to kick off the project. Everything is hosted on github via github pages at http://adron.github.io/junction/ and the git repository at https://github.com/Adron/junction. The video in which I described at a high level each of the sections of the application is located here: http://vimeo.com/adronhall/junction.
• Clive Boulton @cliveb, Jared Wray @jaredwray, Kristen Mozian @kmozian and OJ Reeves @OJ joined the project to help out.
• Issues, as stories and tasks were added to get started with the project. Here’s a first draft of the things we’re all working on. If you’d like to jump in, feel free to ping me and I’ll add you to the project, you can submit a PR (Pull Request) or talk to me about organizing a hackathon to help move the project forward.

Github Issues – Working Items

The easiest way to view these is to log into the Huboard Kanban Board and give a look see of what is in progress and who’s working on what. Currently I’ve outlined the big items that we’re working on and would love a fellow coder to jump in on. If you’re interested, ping me @adron or just jump into the issues list on Github (or view by milestone – i.e. functional area) and comment on the issue you want to dive into, I’ll add you so you can get started!

For the “Call the Doctor (Administration and Maintenance)” part of the application there are a number of questions to answer. How should we connect to Riak to ensure a secure SSH connection? Should we even use SSH? Is there another way to connect to the Riak Cluster for a secure way to administer the cluster?

In the “<Golfing With Your Data (Query, Put, Deletes, Etc. Handling the CRUD)>” one could dive into creating a functional query space to pull data out of a Riak Cluster. A lot of UI work needs to be done in this space, so if you’re up for putting together some awesome windows 8 interfaces, I’d love to hear from you!

Review Summary

At this point we’re moving forward. We’re always looking forward to new participants so reach out if you’re up for helping out!  So until the next two weeks are up, see ya at the Junction!

So I sat down and hacked up a new version of Adron.me. I snagged a site theme and skin from Theme Forest and ran with it. Broke apart each of a few sections to get a minimally viable site up within 24 hours. I got interrupted a few times with a few other things I needed to wrap up, more about those things later. For now I put together the site, check it out @ http://adron.me. I also put together a video of the hack session during various stages of getting the site live.

During the video I also have a few excursions away form the code to help stay focused on the code. At one point I’m actually working on the Junction App too. Also, keep an eye on it and you can see my Sublime 2 usage, iMac, Lenovo Carbon X1, Ubuntu and a whole slew of other tech. More on all those things too, for now… here’s the video.

…and yeah, no real code complexities or such, mostly an excuse to make a video to some oddball dubstep from the scraps of video I put together during building http://adron.me. Hope it was entertaining, cheers – Adron.

The “Client Round Robin Anti-Pattern”

One of the features that is often available in Riak Client software (including the CorrguatedIron .NET Client, the riak-js client and others) is the ability to send requests to the Riak Cluster through a round robin style approach. What this means is each IP, of each node within the Riak Cluster is entered into a config file for the client. The client then goes through that list to send off requests to read, write or delete data in the database.

The client being responsible and knowledgeable about the data tier of the application in an architecture is an immediate red flag! The concept around SoC (Separation of Concerns) dictates that

“SoC is a principle for separating a computer program into distinct sections, such that each section addresses a separate concern.“

Having the client provide a network tier layer to round robin communication with the database leaves us in a scenario that should be separated into individual concerns. Below is some basic guidance on eliminating this SoC issue.

• Client ONLY sends and receives communication: The client, especially in the situation with a distributed system like Riak should only be dealing with sending and receiving information from the cluster or a facade that provides an interface for that cluster.
• Another layer should deal with the network communication and division of nodes and node communication. Ideally, in the case or Riak, and most distributed systems this should be dealt with at the network device layer (router).
• The network device (router) layer would ideally be able to have (through software likely) a way to automate the failure, inclusion or exclusion of nodes with the cluster system. If a node goes down, the network device should handle the immediate cessation of communication with that node from all clients, routing the communication accordingly to an active node.
• The node itself needs to maintain a continual information state available to the network. Ideally the network state would identify any addition or removal of a node and if possible the immediate failure of a node. Of course it isn’t always possible to be informed of a failure, but the first line of defense should start within the cluster itself among the nodes.

The Anti-Pattern

Having the client handle all of these parts of the functional architecture leads to a number of problems, not merely that the guidance of the SoC concept is broken. With the client attempting to track and be aware of the individual nodes in the cluster, it sets the client with a huge responsibility.

Take for instance the riak-js client. If a node goes down the client will need to be aware of which node has gone down. For a few seconds (yes, you have to wait entire seconds at this level) the node will be gone and the client won’t know it is down. The client would just have to reasonably wait. When the communication times out, the client would then have to have the responsibility of marking that particular node as down. At this point the client must track which node it is in some type of data repository local to the client. The client must also set a time or some way to identify when the node comes back up. Several questions start to come up such as;

• Does the client do an arbitrary test to determine when the node comes back up?
• When the node comes back up is it considered alive or damaged?
• How would the client manage the IP (or identifier) of the node that has gone down?
• How long would the client store that the node is down?

The list of questions can get long pretty quick, thus the bad karma of not following a good practice around separating your concerns appropriately! One has to be careful, a god class might be right around the corner otherwise! That’s it for this quick journey into some distributed database usage guidelines. Until next, happy data sciencing.  😉