Register Here

What really matters most when developing mobile applications in today’s consumer driven universe? Start with understanding and embracing both the constraints and capabilities of the mobile platforms. Make sure the mobile app strives to create a delightful user experience. And, finally, be certain, the mobile app is built first for mobile and not for web.

Putting strong focus on the end-user experience is one of the key pillars of the approach used by Buenos-Aires based Globant. The firm has dedicated itself to blending stylistic product design, a healthy dose of next-gen development practices and a savvy awareness of client requirements to produce mind-blowing mobile solutions for clients around the world.

So how does Globant do it and how do these rarified applications really perform?

Our program will examine key use cases and also explore the impact of Globant’s recent acquisition of mobility trailblazer Nextive. We will dedicate some time also to reveal the inner workings of the Globant mobile ‘studio’ where developers regularly participate in the application definition process given their mobile and social expertise in UX and functionality.

Featured Speakers:

• Guillermo Bodnar, CTO - North America, Globant
• Andrew Burgert, GM, Globant Mobile Studio
• John Barrera, Director, Product Management, Aeria Games
• Porter Felton, Executive Producer, Globant Mobile Studio
• Kirk Laughlin, Founder/ Editorial Director, Nearshore America

Register Here

On September 8th, at 4:30 PM, Argentina’s President, Cristina Fernández de Kirchner, visited Globant’s new offices at “Laminar” building in Down-Town Buenos Aires.

She walked around the offices, meeting Globant’s co-founders and employees, and asked about projects that were being worked on. Although not much of a computer fan, she said she was a fan of companies like Globant.

She even posed for a picture in a meeting room full of colorful balls with Globant’s co-founders, Martín Migoya, Guibert Englebienne, Martín Umaran y Néstor Nocetti.

With this acquisition, Globant plans to expand its portfolio of mobile and social services through Nextive’s capabilities. Founded in 2008 in San Francisco, California, Nextive has a broad set of clients in the US, including companies like Crowdstar, GSN and Zynga. Nextive’s team will lead Globant ́s Mobile Studio, adding new practices and increasing its reach. Nextive’s more than 130 professionals will join Globant’s team, working from their development centers in San Francisco, Buenos Aires and Cordoba.

Nextive’s US headquarters will allow Globant to strengthen its presence near its customers and propel its growth in North America. After this transaction, Globant plans to expand the US team. The Company is currently hiring 120 new Globers per month worldwide, and expects to add 200 US-based professionals in the next two years as well.

“We are really excited about this deal. We are glad Nextive is joining us because it will allow us to keep growing in the US. Since we founded Globant, we wanted to create a company that brought opportunities for talent worldwide, so with this acquisition, we will be creating job opportunities for US professionals”, commented Martin Migoya, Globant CEO & Co-founder. He added: “For us it ́s key to continue working on the specialized expertise we have built with our Studios. Nextive strongly complements our knowledge in mobile innovative solutions, which will benefit our customers.”

“Nextive and Globant share the same culture of innovation and challenge. Globant ́s global vision, constant growth and creativity, combined with the experience and talent of both companies, will allow us to augment our services and relationships with customers,” pointed out Martin Umaran, Globant COO, M&A chief & Co-founder.

“We are excited to join the ever-growing Globant team in the US and Argentina, where we will find plenty of challenges and new opportunities with companies like EA, Linkedin and Google. We will also be able to realize the full potential of our combined efforts to produce outstanding mobile and social experiences for larger audiences”, stated Andrew Burgert, Nextive CEO.

About Globant
Globant is the Latin American leader in the creation of innovative software products that appeal to global audiences, specializing in the use of agile methodologies and a rational blend of open source and proprietary software. At Globant we have a holistic view of software development, where the best engineers team up with art design studios and innovation labs to deliver a superb user experience. Globant is a privately held, privately funded company headquartered in Buenos Aires, Argentina with offices in Tandil, Cordoba, Rosario, Resistencia, Bahia Blanca and La Plata in Argentina, San Francisco, New York and Boston in the United States, Montevideo, Bogota, and London. For more information, visit www.globant.com.

Since we are considering using CouchDB for data storage on our apps backend (and possibly on the frontend as well) I cooked this small intro.

Some facts about CouchDB that you should know:

• CouchDB is a JSON document-oriented database written in Erlang.
• It is a highly concurrent database designed to be easily replicable, horizontally, across numerous devices and be fault tolerant.
• It is an open source Apache foundation project.
• It allows applications to store JSON documents via its RESTful interface.
• It makes use of map/reduce to index and query the database.

Users in CouchDB

Be advised! CouchDB, by default, is completely open, giving every user admin rights. This is great for development but obviously bad for production. In the bottom right, you will see “Welcome to Admin Party! Everyone is admin! Fix this”.
Go ahead and click fix this and give yourself a username and password. This creates an admin account and gives anonymous users access to read and write operations on all the databases, but no configuration privileges.
Users are just JSON documents like everything else so you can store any additional attributes you wish like email for example. You can then use groups within CouchDB to control what documents each user has write access to.

Creating a Document

Now we’re going to create our first document using Futon:

1. Open the mydb database.
2. Click “New Document”.
3. Click “Add Field” to begin adding data to the document. Notice how an ID is completed out for you, you should not change this unless you know exactly what you´re doing (and the chances are that you don’t if you’re reading this). Add key “game” with the value of “Nextive CouchDB Tutorial”.
4. Make sure you click the green tick next to each attribute to save it.
5. Click “Save Document”.

Updating a Document

CouchDB is an append only database — that means that new updates are appended to the database and do not overwrite the old version. Each new update to a JSON document with a pre-existing ID will add a new revision. This is what the automatically inserted revision key signifies. Follow the steps below to see this in action:

• Viewing the contents of the mydb database, click the only record visible.
• Add another attribute with the key “type” and the value “game”.
• Hit “Save Document”.

After saving, a new revision key should be visible starting with the number 2. Going back a level to the mydb database view, you will still see just one document, this is the latest revision of our game document.

Creating a Document Using cURL

I mentioned earlier that CouchDB uses a RESTful interface, let’s prove this by inserting a document using cURL via the Terminal.
First, let’s create a JSON document with the below contents and save it to the desktop calling the file person.json.

{
“name”: “Bruce”,
“surname”:  ”Wayne”,
“type”:     ”person”
}

Next, open the terminal in the Desktop then perform the insert with:
curl -X POST http://mysubdomain.iriscouch.com/mydb  -d @person.json -H “Content-Type: application/json”

CouchDB should have returned a JSON document similar to the one below.

{”ok”:true,”id”:”259191a3020fd260d1bb66cf17594757″,”rev”:”1-f62208cb5761dd5c7d1c5954dfba0e7a”}

This is the ID and revision number of the inserted document.

CouchDB follows the RESTful convention so:

• POST – creates a new record
• GET – reads records
• PUT – updates a record
• DELETE – deletes a record

Viewing All Documents

We can further verify our insert by viewing all the documents in our mydb database by executing curl -X GET http://mysubdomain.iriscouch.com/mydb/_all_docs

Creating a Map Function

Viewing all documents is nice, but fairly useless in itself. What if we only want to show all game documents?. Follow the steps below to produce the magic:

• Within Futon, click on the view drop down and select “Temporary View”.
• This is the map reduce editor within Futon. Copy the code below into the map function.




function (doc) {

if (doc.type === “game” && doc.game) {

emit(doc.game, doc);

}

}

• Click run and you should see (if you didn’t mess up)  the single game we added previously.
• Go ahead and make this view permanent by saving it.

After creating this simple map function, we can now request this view and see its contents over HTTP using the following command :
curl -X GET http://mysubdomain.iriscouch.com/mydb/_design/games/_view/games
Notice that we get the document’s ID and revision by default.

Reduce Fat Fast

To perform a useful reduce (on SQL we would call this aggregation), add another game to our database and add a users attribute with the value of 5000 to our first game.

For our new view, we will include a reduce in addition to a map. First, we need to create a map:

function (doc) {
if (doc.type === “game” && doc.users) {
emit(doc.id, doc.users);
}
}

The above map function simply checks to see if the inputted document is a game and that it has users. If these conditions have been met, the game users is emitted. Next, the reduce function:

function (keys, users) {
return sum(users);
}

It takes the users count and returns the sum using one of CouchDB’s built in reduce functions. Make sure you check the reduce option in the top right of the results table as you may otherwise be unable to see the results of the reduce. You need to save the view first to see the results of the reduce.

Conclusion

In this article, we took a brief look at CouchDB, one of the more mature NoSQL database available today. Even the most fervent SQL believer can see the advantages that this type of database offers, especially for high demand write operations.

Credits: Luciano Rubinsztejn

Topics will be the following:

1. Game Development: Why mobile? Where to start? Fragmentation in that market (as compared to iOS)? Virality - how do we measure it?
2. Marketing/Distribution: What do I do with my game after I’ve made it? Big Players can cross promote, what should/can the small players do? Where can I get the most exposure for my game?
3. Monetization: Freemium vs paid models? iOS/Android? Where do I make more money? How do I make money? Which business models work? Which don’t work? What to integrate into my game?
4. Learn from our mistakes: If I could rewind time, what would I do differently? What not to do? What failed? What didn’t work? Things to avoid - back to the future.

Come join us for a night of drinks, learnings, questions, and networking fun! (and someone asking our panelists any scary/embarassing questions about building mobile games!)

Congratulations Joel!

The code with which the Nextive JSON Parser was tested on had a bug, which gave the results we published. After the bug was fixed, the resulting speed wasn’t as fast, although it’s still one of the fastest out there.

The parser, which works for iOS and Mac OS, still has a few things which can improve performance, and we’ll continue working on it until we max it out. In the meantime, we’ll keep posting screenshots with the latest results.

—–
We released our Nextive JSON Parser for iOS and Mac OS on GitHub:
https://github.com/nextive/NextiveJson

We noticed it performs really well on iOS (images below) when parsing Twitter’s public timeline. Please let us know if it makes a difference in your product!

Credits: Martin Adoue and Hernan Pelassini

Hope to see you there!

You can now find us at:

Arturo M. Bas 136, 5th Floor, Suite C, X5000KLD
Ciudad de Córdoba, Argentina
Phone: +54 (351) 598-7140
Map Link

A few pics of our offices:

We are going to use the created Managed Object Context to do CRUD operations (create, read, update and delete).

In the next sections we are going to describe deeper the necessary steps to get a Managed Object Context.

Creating a Data Model

The Data Model represents the entities and relationships mainly. It helps to do the mapping of the objects to the persistent store. Those are the necessary steps to create a Data Model using Xcode ver 3.2.x:

Go to the option File >> New File in the menu, select the iOS / Resource group and choose the option Data Model.

If the project already has data classes we have an option to automatically generate the data model based on that classes. We just have to select which classes we want to add to the data model.

Finally, we are going to see the tool to create our Data Model. This tool is very straightforward to use. Graphically you can create or update you Data Model.

You can see that in the Data Model that we have two entities: Team and Match. Team has an attribute called name and it has two relationships with Match. Match represents a game between two teams. It has as attributes: the date of the match, the score of both teams and it has two relationships to the entity Team. We are going to use this data model to describe some CRUD operations.

Every entity can have:

• Attributes, similar to a field in a record, you can define the type, if it’s optional or not, if it’s indexed, etc.
• Relationship with other Entities: the relationships can be 1 to 1, 1 to N.
• Fetched Properties: It’s some kind of mix between relationships and fetches.

Generating Data Classes from the Data Model

Now that we have a data model created, we can automatically create the data classes that represent the entities defined in the model. Every data class is going to represent an instance of one entity. The generated classes are subclasses of NSManagedObject class.

There are two tools to generate these data classes. One tool is integrated with Xcode and the other one it’s a third party tool called Mogenerator (http://rentzsch.github.com/mogenerator/), the main different with the Xcode tool classes is that Mogenerator creates two set of classes per entity: one for machines, one for humans. The machine class can be always be overwritten to match the data model, while the human class with humans’ work is preserved.

I’m going to describe the steps to generate the classes with Xcode ver 3.2.x:

First, We have to be in the Xcode Data Model tool and go to File >> New File in the menu and choose the group Cocoa Touch Class and select Managed Object Class. If we aren’t on the Data Model tool, we are not going to see the final Managed Object Class option.

Then we have to select the entities from the Data Model that we want to create Data Classes for.

After this we are going to have the Data Classes generated in our project.

Creating a Managed Object Context

In order to make CRUD (create, read, update, delete) operations we need an instance of a Managed Object Context. To create a Managed Object Context we need to follow these steps:

Creating a Managed Object

Now we are going to create two instances for the entity Team and one instance for the entity Match. Match has two relationships with the entity Team. That represents the teams that are going to play on that match.

Executing Fetches

In order to execute fetches we need to create a NSFetchRequest instance. We need to define an entity name, a predicate and the order of the data result. Then we use the created Managed Object Context to execute the generated NSFetchRequest instance. The Managed Object Context returns an array of NSManagedObject objects.

Deleting a Managed Object

In order to delete Managed Objects we need to mark the objects that we want to delete through the Managed Object Context and then persist the changes.

Updating a Managed Object

In order to update Managed Objects we just have to update its attributes values and then persist the changes.

Next steps

I’m going to mention some topics that you should read if you want to learn more about Core Data:

• NSFetchedResultController: This is a controller used to optimize the use of memory when we have to show information on a Table View.
• Versions and Migration: Core Data has some tools to automatically implement updates on our data model.
• Threading: It’s important to understand how to use Core Data on multithread scenarios.

References

• Core Data Tutorial for iOS
• Introduction to Core Data Programming Guide
• The frirst seven chapters from the book “More iPhone 3 Development” - Dave Mark and Jeff LaMarche.
• Book: Pro Core Data for iOS - Michel Privat and Robert Warner.

Author: Pablo Romero