After releasing our new coding interface, a number of users have had difficulty running code and loading exercises over the past week. I apologize for this. These issues are not related to the new interface, but instead are deeper issues with how we evaluate code submissions. I wanted to share the background of what is happening and what we are doing to build a stronger code evaluation platform going forward.

Background

It is possible, but not at all easy to run languages like Ruby, Python, and PHP directly in the browser. In fact we used to do this by serving an interpreter for each language, compiled to JavaScript, to your browser!

We ultimately found this approach to be too fragile to use in production, and last summer we launched the Python language track on top of a server-side code evaluation service that we call Codex. Codex was originally designed to run Python code in a secure environment. As we added new language tracks like Ruby and PHP, we began to push it to its limit.

When we designed the new interface, we built it to be more responsive. Unfortunately this strained Codex in ways it wasn't intended to be used, resulting in spotty performance. Making Codex more robust will let the new interface deliver on its promise.

What we're doing about it

Codex has gone through some significant growing pains as we've rapidly expanded both our user base and the ways we use the service.

We pushed a series of fixes to take it off life-support and are doubling down our investment in it as the backbone of our coding experience. We are refactoring core aspects of the service to handle much larger loads and adding support for multi-process environments (i.e. running mongodb, node.js, and redis together in a single app).

This will ensure that Codex is prepared to grow with users as they tackle an ever increasing variety of topics and technologies. Thank you for your patience, and we're excited to see what you build!

If you are experiencing these issues, please see our support article here.

The “each” method in Ruby on Rails allows you to iterate over different objects inside an array-like structure. It’s an important part of development in Ruby, and Treehouse’s Ruby teacher, Jason, explains how to use it effectively in this Treehouse Quick Tip!

The post How to Use the “each” Method in Ruby on Rails | Treehouse Quick Tip appeared first on Treehouse Blog.

On a desert journey, coffee-scented oases of WiFi.

As loyal readers already know, a few months ago I embarked upon an experiment: I junked my iPhone. Surprising even myself, at the end of the appointed month, I decided not to go back to it. Currently, I make do with a very basic Alcatel phone, together with a hand-me-down dataless Verizon iPhone that I use as a de facto iPod Touch.

Manil Suri, professor of mathematics, was recently a guest on the BBC World Service program “The Forum” to discuss “Obsessions, new and old, in literature and technology.”  Joining Suri on the show, which was hosted by Bridget Kendall, were internet analyst and cyber-sceptic Evgeny Morozo and Spanish novelist and translator Javier Marias.

Suri discussed his recent novel, “The City of Devi,” in which the main character is obsessed with bringing a pomegranate to her missing husband.

“She feels that having this symbol almost will somehow lead her to her husband. And in a way it does tell her something about her marriage, but in a very unexpected fashion,” he said.

The guests also spoke about our obsession with technology.  “There’s this belief in technology and computers – these are going to really save us from having to think,” Suri said.

Pasquale D’Silva’s article Transitional Interfaces has really been making the rounds. It's a quick read that drives home a great point. Transitions and animations can be more than eye candy. They can help give your brain a clue about what is happening on a page.

If a list item is inserted into a list, rather than having it suddenly appear, an animation that moves the list to make room makes it extremely obvious what is going on. Otherwise it's blink-and-you-miss-it.

The animated GIF's in the article make it, so go check that out.

Pasquale wasn't saying do exactly this every time! But they are nice examples so I figured I'd take a crack at making them happen on the web.

Check out the coded examples of transitional interfaces on CodePen.

Nothing groundbreaking, but a couple of tricks at play.

In the list-item-adding examples, the space is made in the list by at first setting the list items to max-height: 0; and having an @keyframes animation run on them which expands the max-height to 50. Careful there to make sure that number is high enough to cover the space with a reasonable enlargening of text.

The @keyframes only have a to { } block. When the from { } or 0% { } block is ommitted, it just starts the animated properties at whatever they are naturally. Height, opacity, and scale are all used here to make it pop into place.

.new-item {
      max-height: 0;
      opacity: 0;
      transform: scale(0);
      animation: growHeight 0.2s ease forwards;
    }
    @keyframes growHeight {
      to { 
        max-height: 50px;
        opacity: 1;
        transform: scale(1);
      }
    }

In the slide-in example, first the space is created in the list, then the item is slide in to that space. That is done by using two different @keyframe animations. One to make the space, the other to do the slide. You can apply them both to a single element, spacing out the time in which they are run.

.new-item {
      max-height: 0;
      opacity: 0;
      transform: translateX(-300px);
      animation: 
        openSpace 0.2s ease forwards,
        moveIn 0.3s 0.2s ease forwards;
    }
    @keyframes openSpace {
      to { 
        max-height: 50px;
      }
    }
    @keyframes moveIn {
      to { 
        opacity: 1;
        transform: translateX(0);
      }
    }

The second animation value has a second time parameter, which is the delay. The delay is the same as the duration of the first animation. So they run in sequence.

In the pop-up details view example, the list item is grown in size by using transform: scale(X); Behind it, the list is hidden from view by also using a scale transform. It makes itself much smaller and hides behind the expanded list item, which transforms many times the size of itself to compensate.

Transitional Interfaces, Coded is a post from CSS-Tricks