Static typing is great because it keeps you out of trouble. Dynamic typing is great because it gets out of your way and lets you get your work done faster. The debate between strongly and dynamically typed languages rages on, but understanding the issue starts with weak typing and languages such as C.

C treats everything like a number. A character like a or 7 or % is the number of the ASCII symbol representing it; “true” and “false” are just 1 and 0.

C defines variables with types such as int for integer and char for character, but that just defines how much memory to use. To access the variable and print it out, I need to know the type.

    int a = 1;
    printf("The number is %i\n", a);
    
    char z = 'z';
    printf("The character is %c\n", z);
    

When I run this program, it shows this:

The number is 1
    The character is z
    

The printf function needs a hint from us to know how to format the variable. If I give the wrong hint…

    char z = 'z';
    printf("The character is %i\n", z);
    

… then I get this:

The character is 122
    

C doesn’t know whether z is a character or an integer; it has a weak type.

Weak typing is fast because there’s no overhead of remembering the different types, but it leads to some nasty bugs. There’s no way to format the z if you don’t know its type ahead of time. Imagine accessing a variable and getting the number 1229799107. The number could be the result of a mathematical calculation (1,229,799,107), the cost of a government program ($1.2 billion) or a date (Saturday, 20 December 2008). When all you have is the number, there’s no way to know that it’s really the code for the letters in my name: zack.

So far, we’ve just covered weak typing. “Weak versus strong” and “static versus dynamic” are often spoken of synonymously, but they each describe a different phase of the same problem. They’re also politicized, with the words carrying an implied value judgment. “Weak versus strong” makes one of them sound a lot better than the other, while “static vs. dynamic” makes one sound stodgy and the other exciting.

(Image: Cris)

These two terms are used interchangeably, but they describe the difference between the way a language defines types and how it figures them out when the program runs. For example:

No programming language fits any of these definitions 100%. Java is considered one of the most static languages, but it implemented a comprehensive reflection API that lets you change classes at runtime, thus resembling more dynamic languages. This feature allows the Java Virtual Machine to support very dynamic languages such as Groovy.

Functional programming languages such as Lisp, Erlang and Haskell blur the lines even more.

Usually when people argue about the merits of strong versus weak programming languages, they really mean the varying degrees of weak, strong, static and dynamic philosophies in every language.

Weak Static Languages: C, C++ And Objective-C

These next programming languages use a subset of C’s functionality and strict guidelines to improve the loose nature of the language. C++ and Objective-C compile into the same bytes as C, but they use the compiler to restrict the code you can write.

In C++ and Objective-C, our number (1229799107) has a meaning. I can define it as a string of characters and make sure that no one uses it as a currency or a date. The compiler enforces its proper use.

Static typing supports objects with sets of functionality that always work in a well-defined way. Now I can create a Person object and make sure the getName function always returns the string of someone’s name.

    class Person {
        public:
            string getName() {
                return "zack";
            }
    };
    

Now I can call my object like this:

    Person p;
    printf("The name is %s\n", p.getName().c_str());
    

Static typing goes a long way to avoid the bugs of weakly typed languages by adding more constraints in the compiler, but it can’t check anything when the program is running because a C++ or Objective-C program is just like C code when it runs. Both languages also leave the option of mixing weakly typed C code with static typed C++ or Objective-C to bypass all of the type checking.

Java goes a step beyond that, adding type checking when the code runs in a virtual machine.

Strong Static Languages: Java

C++ offers some stricter ways of using C; Java makes sure you use them. Java needs everything to be defined so that you know at all times what type of object you have, which functions that object has and whether you’re calling them properly.

Java also stopped supporting C code and other ways of getting out of static typing.

The Person object looks almost the same in Java:

    public class Person {
        public String getName() {
            return "zack";
        }
    }
    

I get the name by creating a new object and calling the getName function, like this:

    public class Main {
        public static void main (String args[]) {
            Person person = new Person();
            System.out.println("The name is " + person.getName());
        }
    }
    

This code creates a new Person object, assigns it to a variable named person, calls the getName function and prints out the value.

If I try to assign my person variable to a different type, such as a character or integer, then the Java compiler will show an error that these types are incompatible. If I was calling a separate API that had changed since I compiled, then the Java runtime would still find the type error.

Java doesn’t allow code outside of a class. It’s a major reason why people complain that Java forces you to write too much boilerplate.

The popularity of Java and its strong adherence to strong typing made a huge impact on the programming landscape. Strong typing advocates lauded Java for fixing the cracks in C++. But many programmers found Java overly prescriptive and rigid. They wanted a fast way to write code without all of the extra definition of Java.

Strong Dynamic Languages: JavaScript, Python, Ruby And Many More

In JavaScript, I define a variable with the keyword var, instead of a type like int or char. I don’t know the type of this variable and I don’t need to until I actually want to access it.

I can define an object in JavaScript with the getName function.

    var person = {
        getName: function() {
            return 'zack';
        }
    };
    
    alert('The name is ' + person.getName());
    

Now I have an object named person, and it has a function named getName. If I call person.getName(), it will result in zack.

I declared person as a var, and I can reassign it to anything.

    var person = {
        getName: function() {
            return 'zack';
        }
    };
    
    person = 5;
    
    alert('The name is ' + person.getName());
    

This code creates a variable named person and assigns it to an object with a getPerson function, but then it reassigns that variable to the number 5. When this code runs, the result is TypeError: Object 5 has no method 'getName'. JavaScript says that the object 5 doesn’t have a function named getName. In Java, this error would come up during compilation, but JavaScript makes you wait for runtime.

I can also change the type of the object based on the conditions of the program.

    var person = {
        getName: function() {
            return 'zack';
        }
    };
    
    if (new Date().getMinutes() > 29) {
        person = 5;
    }
    
    alert('The name is ' + person.getName());
    

Now this code will work at 9:15 but will fail at 9:30. Java would call this a type error, but it’s fine in JavaScript.

The most popular form of dynamic typing is called “duck typing” because the code looks at the object during runtime to determine the type — and if it walks like a duck and quacks like a duck, then it must be a duck.

Duck typing enables you to redefine any object in the middle of the program. It can start as a duck and turn into a swan or goose.

    var person = {
        getName: function() {
            return 'zack';
        }
    };
    
    person['getBirthday'] = function() {
        return 'July 18th';
    };
    
    alert('The name is ' + person.getName() + ' ' + 
          'and the birthday is ' + person.getBirthday());
    

At any point, I can change the nature of my Person object to add the new getBirthday function or to remove existing functionality. Java won’t allow that because you can’t check object types when they’re always changing. Dynamically redefining objects gives you a lot of power, for good and bad.

C shows errors when the program runs. C++, Objective-C and Java use the compiler to catch errors at compile time. JavaScript pushes those errors back to the runtime of the application. That’s why supporters of strong typing hate JavaScript so much: it seems like a big step backward. They’re always looking for JavaScript alternatives.

Which Is Better?

I’m looking for a program to parse XML, find a particular element, make a change and save the file. On a team of Java programmers, I wrote the code in the dynamic language Python.

import sys
    import string
    from xml.dom.minidom import parse
    
    dom = parse(sys.argv[1])
    
    for node in dom.getElementsByTagName('property'):
        attr = node.attributes['name'];
        if attr.value == 'my value':
            node.childNodes[0] = dom.createTextNode('my new value');
    
    file = open(sys.argv[1], 'w');
    file.write(dom.toxml('UTF-8'));
    file.close();
    

This program finds every property node with the name my value and sets the contents to my new value. I define the variables dom for my XML document, node for each node of XML that I find, and attr for the attribute. Python doesn’t even require the keyword var, and it doesn’t know that node has childNodes or that attr has value until I call it.

To change an XML file in Java, I would write a new class, open an input stream, call the DOM parser, traverse the tree, call the right methods on the right elements, and write the file out to an output stream. I could simplify some of those calls with a library, but I’d still have the overhead of defining my static types. All of the extra definition of objects and variables could easily take a hundred lines. Python takes 14.

Dynamic code is generally shorter than static code because it needs less description of what the code is going to do. This program would be shorter in Python than in C++ and shorter in Ruby than in Objective-C.

So, which is better?

Static typing made our Person object easier to understand. We defined a Person with a name and agreed about which fields mattered ahead of time. Establishing everything clearly makes our Person easier to debug but harder to change.

What happens when someone in our application needs a second email address? In a static language, we’d need to redefine the object so that everyone has two email addresses, even though most people don’t. Add in a birthday, favorite color and a few more items and every Person will have twice as many fields as they need.

Dynamic languages make this problem much easier. We can add a second email field to one Person without adding it to everyone. Now, each object has only the fields it needs. A static language could handle this with a generic map of values, but then you’re fighting the static environment to write dynamic code. C programmers spent years tearing their hair out over errors in type conversions, corrupt values, and the terrible bugs that come from small typos. They’ve been burnt by weak typing, and dynamic typing looks weak.

Dynamic programmers spent years banging their heads over the rigidity of static languages, and they crave the freedom to make the languages do what they want.

I’ve seen static code get overly complex and become impossible to follow. Try debugging an enterprise JavaBean or understanding all of the details of generics in Java. I’ve seen dynamic code turn into a giant mound of unmaintainable spaghetti. Look at the myriad of terrible JavaScript programs before jQuery. Node.js does some amazing things, but I can’t look at it without traumatic flashbacks of horrible JavaScript that I’ve debugged.

Conclusion

There’s no clear conclusion. Dynamically typed languages are popular now. The pendulum will swing back and forth many times in the coming years. The only solution is flexibility. Learn to work in each environment and you’ll work well with any team.

Image credits of image on front page: Alexflx54

(al) (ea)

© Zack Grossbart for Smashing Magazine, 2013.

It’s like biting your nails. It’s like sucking your thumb. It’s like cursing too much. We all have some bad habits, some we just cannot seem to shake. I’m not sure why that is. I mean, no matter how wrong you know it is or how bad it is for you, it’s just impossible to stop.

And have you realized that half the time you don’t even notice? Tomorrow, you can look down at your nails and wonder where they’ve disappeared to. And eventually, you’ll remember that you happily nibbled them off.

As a designer, you’re probably no different. You’re a human and no one is perfect, plus design is just a tough industry. Sometimes, we are our own worst enemies with the things we do and we never seem to notice, nor do we stop. Being a designer, there are four things I notice most often that I and my colleagues do:

1. Aesthetics vs. ease of use

We are designers. We are not artists. We are asked to fix problems, create solutions and design things. I could even say, though a stretch, that we are scientists.

Artists typically have less or no rules and make things that make them feel good. But as designers, at the very least, we have to make something that makes our client (and eventually their customer) feel good. We shouldn’t be in the league of creating something pretty. We should be able to do that when necessary, but that shouldn’t be our priority. We must focus on ease of use or making things that make sense.

It’s the reason why we hate fonts like Comic Sans and Papyrus, but love Helvetica. One is readable and serves as a great body font. The others? Well, not so much. Things have to make sense before we make them pretty. It’s why we create sketches and request thorough design briefs before designing a project.

From our navigation menus to our image placement to the bullets we use, it has to be easy to understand. Far too many designers are stuck on an aesthetics first. Projects begin and end with looks rather than how to make things better and easier to understand. And it’s really easy to become concerned with looks when there are so many good designs with a high aesthetic quality. But I’ve learned when you pay attention to creating something with a purpose, aesthetics tend to fall right into place.

2. Looking at trends

We all do it. We look to the new trends list and the infinite number of inspiration posts. And there’s nothing wrong with being up to date, but we have to be really careful with copying and emulating things that are already being done. 

It’s the difference between your web design being regular and being a stand out. We have to use these trends and inspiration as a means to learn how to approach different problems and situations. We’ve got to digest them and regurgitate something new and better.

If we’re serious designers, we have to be forward thinkers who are always looking for the next big thing. How many vintage badges and seals have you seen? How many huge Helvetica or Futura headlines have you seen? Now when are you going to be the person to set the next trends as opposed to following?

3. Only inspired by web design

We just talked about how we love to eat up the new trends that every design is already doing. But something I take great issue with is that we really are only inspired by similar things. We aren’t expanding our inspiration much, unless we’re taking print ideas and putting them on the web. Otherwise, we get inspired for web design by web designs.

Design (and art) tend to make us feel things and allow us to process things differently. By only being inspired by other web design for your web project or other flyer designs for your flyer project, you are cheating yourself out of good things. 

Architecture, photography and even areas like furniture design can open up your eyes to new solutions for 3-column layouts, for example. Checking out some fashion design may give you an idea of what kind of textures and patterns you may want to use for a brand. I’ve even been inspired by a picture frame for a logo design. Anything works.

Also, taking a look into different areas of designs helps to free your mind a bit. It allows you an opportunity to think about your project from a different angle. It enhances your creativity so that you can be more creative with the work you’ve got to do. Taking a look at something different can make all the difference in your designs.

No matter the concentration or area, many designs have faced similar problems you’re trying to solve. Why not attempt to find different approaches and different solutions?

4. Moaning and groaning

I’ve rarely met a designer who hasn’t whined about something. It could be client who’s too cheap or the one who doesn’t understand why it’s taking so long for a “simple” logo. Whichever it is, graphic designers just whine and get upset and never stop. I guess we feel underappreciated and underpaid and just like to have pity parties.

Whatever. I say stop. Right now. Put your foot down with bad clients and remind them of your worth and what you’re doing. When I start a project, I outright let them know the way the relationship works and give them time tables for things. If there’s an issue there, then I immediately know we aren’t a good fit. Also, a trick is to add a couple days or weeks onto your timetable for safety reasons.

No one understands the life of a designer and if you’re really good, chances are you make what you do look real easy. Clients probably don’t have a clue and don’t understand. Clients who are cheap don’t understand the concept of quality nor do the get the difficulty of what you’re doing. If your work, timetables and design process cannot be respected, then save yourself the headache and move right along.

Many don’t understand the worth of designers, and it’s not really their fault. Businesspeople are concerned about their customers and making money and the like. Spending money on something like design may not be what matters to some. And I can guarantee you, that’s not the person you want to work for. Never be afraid to say ‘no’ and never be afraid to respectfully stand up for yourself.

I’m not telling you to overcharge, nor am I telling you to be a snob to your clients, but it’s absolutely necessary that there’s a level of respect in your working relationships. For every cheap client and headache you say no, there’s a good client out there looking for you!

Conclusion

So you can put hot sauce on your thumb or disgusting nail polish on your nails in an attempt to get you to stop, but when you boil it down, you just have to make a conscious decision to make your change. Doing so makes designing much easier and even liberating. There was a point when I decided to make a change it just felt like I wasn’t even working any more. I was just enjoying what I do and making great things. Now it’s your turn. What are you going to stop doing today?

What are some subconscious things you notice you do? Could stopping make you a better designer? Let us know in the comments.

Beginner’s Course: Learn HTML5 & CSS3 Web Design – only $27!

Slumping PC sales and a changing server market are maiming Intel. But its plan to sell services for the home’s biggest screen is a long shot.

When Intel lifted the veil from its stealthy media division in February, many outsiders scratched their heads. Why was the chip manufacturer, which has tried and failed to sell consumer products before, trying to launch a TV service, one of the trickiest consumer markets of all?

With over 50,000 Typemock users worldwide, we have seen time and again cases where developers - who believe in the benefits of Unit testing – drop it after facing opposition from management, harsh deadlines or other early challenges. Typemock wants to help developers overcome the early obstacles they face.

I hope that you’re starting to see that Ember.js is a powerful, yet opinionated, framework. We’ve only scratched its surface; there’s more to learn before we can build something truly useful! We’ll continue using the Ember Starter Kit. In this portion of the series, we’ll review accessing and managing data within Ember.

Playing with Data

In the last article, we worked with a static set of color names that were defined within a controller:

App.IndexRoute = Ember.Route.extend({
     setupController: function(controller) {
       controller.set('content', ['red', 'yellow', 'blue']);
     }
    });

This allowed the controller to expose the data to the index template. That’s cute for a demo, but in real life, our data source will not be a hard-coded array.

This is where models comes in. Models are object representations of the data your application uses. It could be a simple array or data dynamically retrieved from a RESTful JSON API. The data itself is accessed by referencing the model’s attributes. So, if we look at a result like this:

{
       "login": "rey",
       "id": 1,
       "age": 45,
       "gender": "male"
    }

The attributes exposed in the model are:

• login
• id
• age
• gender

Data itself is accessed by referencing the model’s attributes.

As you see from the code above, you could define a static store, but you’ll use Ember.Object for defining your models most of the time. By subclassing Ember.Object, you’ll be able to return data (e.g.: via an Ajax call) and define your model. While you can explicitly set data within a controller, it’s always recommended that you create a model in order to adhere to separation of concerns and code organization best practices.

Alternatively, you could use a sister framework called Ember Data. It is an ORM-like API and persistence store, but I need to stress that it is in a state of flux as of this writing. It has a lot of potential, but using Ember.Object is much safer at this time. Robin Ward, co-founder of Discourse, wrote a great blog post on using Ember without Ember Data. It outlines their process, which I’ll break down for you.

Defining your Models

In the following example, I’m going to use the unofficial Hacker News API to pull JSON-based data from the news resource. This data will be stored in my model and later used by a controller to fill a template. If we look at the data returned from the API, we can understand the properties we’ll be working with:

{
      "nextId": null,
      "items": [{
              "title": "Docker, the Linux container runtime: now open-source",
              "url": "http://docker.io",
              "id": 5445387,
              "commentCount": 39,
              "points": 146,
              "postedAgo": "2 hours ago",
              "postedBy": "shykes"
          }, {
              "title": "What\u0027s Actually Wrong with Yahoo\u0027s Purchase of Summly",
              "url": "http://hackingdistributed.com/2013/03/26/summly/",
              "id": 5445159,
              "commentCount": 99,
              "points": 133,
              "postedAgo": "2 hours ago",
              "postedBy": "hoonose"
          },
      ],
      "version": "1.0",
      "cachedOnUTC": "\/Date(1364333188244)\/"
    }

I want to work with the items property, which contains all of the headlines and story information. If you’ve worked with SQL databases, think of each element of items as a record and the property names (i.e.: title, url, id, etc.) as field names. It’s important to grok the layout because these property names will be used as the attributes of our model object—which is a perfect segue into creating the model.

Ember.Object is the main base class for all Ember objects, and we’ll subclass it to create our model using its extend() method.

To do this, we’ll add the following code to js/app.js immediately after the code that defines App.IndexRoute:

App.Item = Ember.Object.extend();

App.Item serves as the model class for the Hacker News data, but it has no methods to retrieve or manipulate that data. So, we’ll need to define those:

App.Item.reopenClass({
      all: function() {
          return $.getJSON("http://api.ihackernews.com/page?format=jsonp&callback=?").then(function(response) {
            var items = [];
    
            response.items.forEach( function (item) {
              items.push( App.Item.create(item) );
            });
    
    	      return items;
          });
      }
    });

Let’s break down this code. First, we use Ember’s reopenClass() method to add our new methods to the App.Item class, and you pass it an object that contains our desired methods. For this example, we only need one method called all(): it returns all of the headlines from the Hacker News frontpage. Because jQuery is part of the deal with Ember, we have its simple Ajax API at our disposal. The API uses JSONP to return JSON data; so, I can just use $.getJSON() to make the request to:

$.getJSON("http://api.ihackernews.com/page?format=jsonp&callback=?")

The “callback=?” tells jQuery that this is a JSONP request, and the data (once it’s retrieved) is passed to an anonymous callback handler defined using jQuery’s promises functionality:

.then(function(response) {...});

I can easily pump in my JSON data into an Ember object.

The response parameter contains the JSON data, allowing you to loop over the records and update the local items array with instances of App.Item. Lastly, we return the newly populated array when all() executes. That’s a lot of words, so let me summarize:

• Create your new model class by subclassing Ember.Object using extend().
• Add your model methods using reopenClass().
• Make an Ajax call to retrieve your data.
• Loop over your data, creating an Item object and pushing it into an array.
• Return the array when the method executes.

If you refresh index.html, you’ll see nothing has changed. This makes sense because the model has only been defined; we haven’t accessed it.

Exposing Your Data

Controllers act like proxies, giving you access to the model’s attributes and allowing templates to access them in order to dynamically render the display. In addition to accessing attributes from an associated model, controllers can also store other application properties that need to persist without saving to a server.

Currently, our app has the following controller (the one that defines a static data set):

App.IndexRoute = Ember.Route.extend({
      setupController: function(controller) {
        controller.set('content', ['red', 'yellow', 'blue']);
      }
    });

We can directly associate our model with App.IndexRoute using the model method (AKA the model hook):

App.IndexRoute = Ember.Route.extend({
      model: function() {
        return App.Item.all();
      }
    });

Remember that Ember defines your controller if you don’t explicitly define it yourself, and that is what’s happening in this case.

Behind the scenes, Ember creates IndexController as an instance of Ember.ArrayController, and it uses the model specified in the model method.

Now we just need to update the index template to access the new attributes. Opening index.html, we can see the following Handlebars template code:

{{#each item in model}}
        <li>{{item}}</li>
    {{/each}}

With one small change (adding the title property), we can immediately see the titles returned from the Hacker News API:

{{item.title}}

If you refresh your browser now, you should see something similar to the following:

<h3>Welcome to Ember.js</h3>
    <ul><li>Persona is distributed. Today.</li>
    <li>21 graphs that show America's health-care prices are ludicrous</li>
    <li>10 000 concurrent real-time connections to Django</li>
    <li>Docker, the Linux container runtime: now open-source</li>
    <li>Let's Say FeedBurner Shuts Down…</li></ul>
    

If you want to display more information, simply add more properties:

{{item.title}} - {{item.postedAgo}} by {{item.postedBy}}

Refresh to see the updates you’ve made. That’s the beauty of Handlebars; it makes it trivial to add new data elements to the user interface.

As I mentioned before, controllers can also be used to define static attributes that need to persist throughout the life of your application. For example, I may want to persist certain static content, like this:

App.IndexController = Ember.ObjectController.extend({
      headerName: 'Welcome to the Hacker News App',
      appVersion:  2.1
    });

Here, I subclass Ember.ObjectController to create a new controller for my index route and template to work with. I can now go to index.html and update my template to replace the following:

<h2>Welcome to Ember.js</h2>

with:

<h2>{{headerName}}</h2>

Models are object representations of the data your application uses.

Handlebars will take the specified attributes in my controller and dynamically replace the {{headerName}} placeholder with its namesake value. It’s important to reinforce two things:

• By adhering to Ember’s naming conventions, I didn’t have to do any wiring to be able to use the controller with the index template.
• Even though I explicitly created an IndexController, Ember is smart enough not to overwrite the existing model that’s been associated via the route.

That’s pretty powerful and flexible stuff!

Next up…Templates

Working with data in Ember isn’t difficult. In actuality, the hardest part is working with the various APIs that abound on the web.

The fact that I can easily pump in my JSON data into an Ember object makes management substantially easier—although I’ve never been a big fan of large data sets on the client-side, especially when represented as objects.

It’s something I’ll have to do more testing on, and I hope that Ember Data makes all of this trivial.

With that said, I briefly touched on templates in this article. They’re very important… so much so that I want to tackle this topic in its own article. So in the next article, we’ll go over how to leverage Handelbars to build your user interface and drill-down into the various directives the templating framework offers.

Many web services offer an accidental megaphone. They need to protect us from ourselves.

I haven’t used Facebook’s Groups feature, but today brings news that the company is boosting its visibility by adding the section to users’ Timeline pages. On some intuitive level, this bothers me: Groups is about having private conversations among friends and colleagues, reportedly. Yet the Timeline is one of the most visible, public parts of a Facebook user’s page. So what gives?