We have recently incorporated in Hexacta a new agile project management methodology that easily adapts to the project needs when their requirements definition is not given in its initial stage of inception, but occurs during the course of it.
Kanban is a Japanese word that can be translated as “visual cards” (kan: visual, ban: card).  It emerged as a consequence of a methodology called Lean, built by Toyota to improve its production using Just in Time techniques (JIT).  Kanban is not a specific technique for software development and its goal is to manage, in a more general way, how tasks are expected to be completed.

The main three rules are the following:
•    Take into account the phases of the production cycle or workflow.
•    Determine the limit of “work in progress” (or WIP).
•    Measure the time spent in order to complete a task (known as “lead time”).
For a better understanding, here’s a comparison between Scrum methodology, with which we have been working for some time now, and Kanban:

I personally believe that the best strategy to apply depends on how client requirements are managed:
•    Full Scrum: when client participates actively and has a defined number of requirements.
•    Full Kanban: when there are no defined requirements.
•    Mixed: Scrum for development, Kanban for bug fixing.

The 50 million users of Farmville (online game where the player is responsible for its virtual farm) may not have much fun while playing, but they are a good example of a curious phenomenon that is rooted in the fear of humans towards losses. They are a perfect case of the “sunk cost fallacy” that affects both the online gaming world and business decisions taken by companies.

The sunk cost is an expense or investment that once made cannot be recovered. So the sunk cost fallacy is a behavior that is manifested in the trend to maintain a course of action when money, time or effort have been invested in it, but a simple analysis makes it clear that only the incremental costs and benefits should be taken into account when making a decision.
And this is, in the words Sizhao Zao Yang, co-creator of Farmville, one of the foundations of the success of the game: “Farmville uses a concept called appointment gaming, which is based on the fundamental concept of using time and investment to make the player return. This concept is called the sunk cost fallacy. The investment made in the game is crucial to make the player feel psychologically attracted to return … “.

Studies made by Kahneman and Tversky in the 70s pointed out that people risked only a certain amount with the promise of a prize twice as big. The conclusion was that the fear of loss is at least two times greater than the interest in winning. The fear of loss is a major human motivational factor. Animals and children, according to Plaisier and Webley studies, are much less susceptible to this effect.

And this force is evident in the mechanics of Farmville, where players engage in the virtual world, and not honoring the commitments has consequences: if the player does not return, his work in the game (crops and animals) is wasted, leaving the player with a sense of loss. Of course you can pay real money to avoid these losses. And this triggers a cycle, in which the player does not play to enjoy, but to avoid negative feelings or chooses to pay to avoid them.

What happens in the software industry?

This phenomenon occurs in all spheres of our lives, and also happens to teams developing software. Imagine a team working on a new module for its client. What should be considered when the development is in an advanced stage and the client reports business changes that affect the architecture? Re-do everything that has been developed, or somehow try to adapt the existing? Time and effort invested will be “wasted” if you decide to redefine the module … although this module is not perfect it should be finished. On the other hand, the redefinition will make the system better reflect and meet the client’s business objectives. In light of the above, the team will tend to overestimate the time and effort invested. To avoid “losing” this investment, unrecoverable anyway, the decision will be in most cases to continue over the previous road instead of restarting the work. An objective technical analysis would certainly recommend reengineering to achieve the best solution.

This also applies to decisions to implement systems for large companies. In a surprisingly large number of cases development and deployment of technologies are continued even though they are already known not aligned with the new strategic objectives of the company.

Integration

OpenLayers supports the standard WMS that allows to connect to different map servers that can work with that standard. This means that any other type of MapServer or GeoServer map server could be used as a map provider.
Alternatively, you can use Google´s map server images to browse with OpenLayers. This means that OpenLayers would allow to “move” and “zoom” the map and Google will be in charge of providing the images for each zone. Not only Google can be used as an images provider, but also Yahoo or Bing, among others.
This functionality brings a key advantage in terms of using Google, Yahoo or Bing’s library. It allows abstracting from the map provider, which allows changing it without having to migrate the code. It also allows the developer to use a provider, such as Google, until her own map server is running.

Layers

The layers represent the images sources that can be displayed by OpenLayers.
Layers are classified into Base Layers, Non Base layers (Overlays) and Raster Layers.
The most common layer scenario is the BaseLayer, which represents the essential characteristic of the map. A base layer could be a satellite, hydrographic, lifting or streets map.
The base layers are mutually exclusive, meaning that only one base layer can be shown at a time. Fortunately, OpenLayers allows adding a browsing control that provides a switch to change between base layers.
An example of an OpenLayers map with many layers:

1  var map;
2
3  function initMap() {
4  map = new OpenLayers.Map(‘map’);
5  map.addControl(new OpenLayers.Control.LayerSwitcher());
6
7  var gphy = new OpenLayers.Layer.Google(
8  “Google Physical”,
9 {type: google.maps.MapTypeId.TERRAIN}
10 );
11  var gmap = new OpenLayers.Layer.Google(
12 “Google Streets”, // the default
13 {numZoomLevels: 20}
14  );
15  var ghyb = new OpenLayers.Layer.Google(
16 “Google Hybrid”,
17  {type: google.maps.MapTypeId.HYBRID, numZoomLevels: 20}
18  );
19  var gsat = new OpenLayers.Layer.Google(
20 “Google Satellite”,
21 {type: google.maps.MapTypeId.SATELLITE, numZoomLevels: 22}
22  );
23  var wms = new OpenLayers.Layer.WMS( “WMS”, “http://osgeolive/cgi-bin/mapserv?”,
24 {map: ‘/home/user/Mapas/Argentina/argentina.map’,
25  layers: ‘default’,
26  transparent: ‘off’},
27  {maxExtent: new OpenLayers.Bounds(-9548635,-5889094,18604187,-597430),
28  scales: [5000,10000,25000,50000,100000,250000,500000,
29  1000000,2500000,5000000,10000000,25000000,50000000,100000000],
30  units: ‘m’,
31   projection:new OpenLayers.Projection(“EPSG:900913″)} );
32
33  map.addLayers([gphy, gmap, ghyb, gsat, wms]);
34
35  // Google.v3 uses EPSG:900913 as projection, so we have to
36  // transform our coordinates
37  map.setCenter(new OpenLayers.LonLat(-34.57215,-58.42984), 5);
38  }

For more details on OpenLayers layers, refer to: http://docs.openlayers.org/library/layers.html

Overlays

The overlays are features that can be added to a map, for instance, a marker, a polygon, or a line that can be drawn over the map.
OpenLayers provides methods that allow adding these overlays to a map on a page.
Example:

1 var map;
2
3  function initMarkerMap() {
4  map = new OpenLayers.Map(‘map’);
5  var wms = new OpenLayers.Layer.WMS(“OpenLayers WMS”,”http://vmap0.tiles.osgeo.org/wms/vmap0″,{layers: ‘basic’});
6
7  var feature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(0, 0), { type: 5 });
8  var points = new OpenLayers.Layer.Vector(“Points”);
9  points.addFeatures(feature);
10 map.addLayers([wms, points]);
11
12 var select = new OpenLayers.Control.SelectFeature(points, {hover: true});
13 map.addControl(select);
14 select.activate();
15
16 map.setCenter(new OpenLayers.LonLat(0, 0), 1);
17 }

To set a marker over a point:

1 function addPointOnClic(eventArgs) {
2 var lonlat = map.getLonLatFromViewPortPx(e.xy);
3 var lon = lonlat.lon;
4 var lat = lonlat.lat;
5
6 var pointLayer = new OpenLayers.Layer.Vector(‘Points’, { styleMap: myStyles });
7 map.addLayers([pointLayer]);
8 var bPoint = new OpenLayers.Geometry.Point(lon , lat)
9 newpoint = new OpenLayers.Feature.Vector(bPoint);
10 pointLayer.addFeatures(newpoint);
11 }

Events

As Google Maps, OpenLayers presents events that can be used, such as:
•    mouseover
•    mouseout
•    mousedown
•    mouseup
•    mousemove
•    click
•    dblclick
•    resize
•    focus
•    blur
•    moveend
•    zoomend
•    changelayer
•    changebaselayer

An example of listeners attached to maps:

1 map = new OpenLayers.Map(‘map’, {
2 eventListeners: {
3 “moveend”: mapEvent,
4 “zoomend”: mapEvent,
5 “changelayer”: mapLayerChanged,
6 “changebaselayer”: mapBaseLayerChanged
7 }
8 });

These events rely on functions that know how to handle them when they arise.
It is important to highlight that OpenLayers’ mobile version presents a series of “touch events” that can be used, such as pinch, touch or tap, making it possible to take the advantages of OpenLayers to the mobile world.

Customization:

Openlayers allows completely customizing all of its controls by changing certain classes of css, creating a different look & feel from other providers, such as Google or Bing.
This page is a good example: http://dev.openlayers.org/releases/OpenLayers-2.11/examples/panel.html.
The example’s css file can be found at:

http://dev.openlayers.org/releases/OpenLayers-2.11/theme/default/style.css

Mobile

As it was mentioned before, OpenLayers presents a version specifically optimized for mobiles, which includes touch, pinch and tap events. All these features make OpenLayers a good choice for closed solutions, such as Google Maps or Bing Maps.
Versatility and independence are the main characteristics of this library.
Another layer that can be added to GIS stack, with the aim of optimizing the response time to the map server calls, is specially prepared caches. Among which we can find: TileCache and GeoWebCache.

TileCache

TileCache is an implementation of the WMS Tile Caching protocol written in Python. The implemented protocol is a standard proposed by OSGeo, which can be accessed by any client that supports that communication.
OpenLayers communicates with Tilecache, like any other WMS.C. This allows Openlayers to be independent from any cache to be used.
TileCache only needs to access a disk to function correctly. Besides of using the disk, TileCache can be set to use libraries such as Memcached. The caches it supports can be found at the following link: http://tilecache.org/docs/Caches.html
The use of one cache improves the map server performance and decreases the CPU usage by reducing the need to access the data base that generates the maps.
The TileCache configuration is simple, but requires GIS knowledge. First the apache must be set to delegate in TileCache by placing the following code inside an apache directory:

1 AddHandler python-program .py
2 PythonHandler TileCache.Service
3 PythonOption TileCacheConfig /var/www/tilecache/tilecache.cfg

After this, the layers that need to be served must be set in tilecache.cfg. An example of a layer is:
[basic]
type=MapServerLayer
layers=basic
mapfile=/home/mapserver/basic.map
debug=off
description=Basic map

TileCache can be set, among other things, to use different resolutions for each selected layer. An axample of a much more complex configuration is:
[massgis-reprojected]
type=ArcXML
url=http://maps.massgis.state.ma.us/servlet/com.esri.esrimap.Esrimap?ServiceName=coq2005hsde_with_roads&ClientVersion=4.0
projection=@/path/to/target_projection # Either a string, or if prefixed by @, an absolute path to a projection in WKT.
layers=14
bbox=218337.16112593404,889611.9317974453,248183.9359890727,914312.7109945256

For more information about layers, click here.

Conclusion

With this post we conclude the review on the main layers inside GIS stack.
There are several useful tools for different functions inside the GIS stack. The standards set the path for the development of many tools, which created these ecosystems.
On the GIS posts, our intention is to present the subject with the most simple and comprehensive information, explaining how each of the tools interact.
Getting the whole stack to run correctly is not an easy task, but once we do it, we obtain a complete solution to compete with Google or Bing.

The aim of this post is to present the Scala programming language in the frame of a typical Java development environment, using Maven and Eclipse to compile sources making both languages (Java and Scala) coexist in the same solution.

Introduction

Scala is a multiparadigm programming language strongly typed that combines the features of object oriented programming and functional programming.
It has many interesting characteristics, such as traits, type inference, pattern matching or implicit functions, which make it a complete and powerful language.  You can find more detailed information on the subject at Scala´s site: http://www.scala-lang.org/.
One remarkable feature is that it functions on the Java Virtual Machine, making it possible to reuse existing Java code from Scala.

Installation

Scala´s plug-in can be installed directly from Eclipse following these steps: “Help → Software Updates … → Available Software”, and adding the corresponding address to the version we want to install (consult the download section at the official site: http://www.scala-ide.org/).

Let´s start with a simple implementation of the famous “Hello World” to check that the installation was successful. Inside the Scala perspective, follow the next steps: File → New → Scala Proyect”, to create a Scala Project and name it “HelloWorld”. Then create a Scala object with the same name in the following way:

In Scala, classes can´t have static attributes like in Java. However, it gives the chance to create singletons objects using “object” in a simple way, as it can be seen in the case “Hello World”.

Integrating Scala with Maven and Eclipse

Scala can be integrated with other Java technologies in such a way to take advantage of the language, but using the java community frameworks such as Maven, Hibernate, Spring, Wicket, etc.
The first thing to do is install Maven, which process is analog to the one for the plug-in. For more information check the official web site: http://www.assembla.com/spaces/scala-ide/wiki/With_M2Eclipse.

If you have an instance of m2clipse already installed in Eclipse, erase it before continuing. Two maven instances would be installed, which can cause some trouble.

Setting up the project using Maven from Eclipse:

1.    File → New → Project
2.    Maven → Maven Project
3.    Enter  “scala” in the filter and select:
Group Id: org.scala-tools.archetypes
Artifact Id: scala-archetype-simple
4.    Next
5.    Complete information with:
GroupId: com.hexacta
ArtifactId: Scala
Package: com.hexacta
6.    Finish
By default some tests are generated. To check there were no problems in the creation, make a ‘Run configuration’ for the project with the goals: ‘clean install’. If you are using Maven for console, use instead “mvn clean install”.
In case Eclipse doesn´t recognise the project as a Scala one (for instance, it doesn´t allow navigating through classes using F3), follow these steps: “right click on the project→ Maven → Update Maven Configuration…”.
This is how Java and Scala can co-exist, compiling with Maven and in Eclipse.

Conclusions:

Scala has the advantage of compiling a byte code, which allows running any Scale program over Java virtual machine, making it easy to integrate with Java technologies. Therefore you can take advantage of:
1.    the excellent benefits that Java´s Virtual Machine provides in terms of performance and security.
2.    the countless libraries and frameworks that exist for Java, which can be used without having to start from scratch.
3.    Scala as a language, which provides an alternative to Java.

References

• Scala Programming Language, Dean Wampler & Alex Payne, O’Reilly
• Roundup: Scala for Java Refugees, http://www.codecommit.com/blog/scala/roundup-scala-for-java-refugees
• Scala IDE for Eclipse, http://www.scala-ide.org/

If we’d rather design the screen by coding it, we can use .xml files in eclipse and then see the final result in the Android emulator or in the device on which Android is running. Currently, the market offers a number of applications, among which DroidDraw Beta stands out.  This is a java desktop application that generates xml code from a graphic design done on a screen simulating Android App.

This .xml code will have to be imported in the corresponding Android application.

While the code generated is similar to what is usually developed mitt, often the differences are obvious and the .xml must be modified to resemble the code we need.
From the ADT 11.0.0, released last June, numerous improvements have been achieved, including the Visual Layout Editor (completely changed). Among them, we can highlight the following:
•    Different widgets and configurations in “Palette”, which can be dragged in our design (drag and drop).
•    Different custom views (different implementations of the View class) can be made and added to our design.
•    Support for fragments (defined portion of a UI in an Activity) mainly used for the tablets screens design.
•    Design facilitated considering the size of the screen, the mobile device, SDK and other factors.
•    Basic Support for the management focus for text field, menu, and items (request and clear Focus).
This new version of the Visual Layout Editor inside Android´s ADT facilitates the design of the user interface, with the advantage of having a tool that is already integrated into eclipse, which allows us to see the layout as we do it.

A brief example
•    We’ll design a screen in Eclipse with the help of Visual Layout Editor of Android´s ADT.

•     We can see what the xml code turned out to be by accessing the flap main.xml

•    Some strings and list values will have to be defined in the “Values” folder of our project.  We can define it from the resources flap or the strings.xml flap. Resources, such as Activity, are independent of the Visual Layout Editor and there’s no change in the way we define them.

• Some useful links:
Official:
•    http://www.google.com/events/io/2010/sessions/android-ui-design-patterns.html
•    http://developer.android.com/sdk/eclipse-adt.html
Non Official:
•    http://www.androiduipatterns.com

Summarizing, the main benefits of Light Switch are:
•    It is a simple and fast way to construct Enterprise applications.
•    Uses the latest Microsoft technologies, the same we use in the applications we construct every day.
•    It allows us to create applications that can run in the desktop of a client, in the web or in the cloud.
•    It is simple enough so that a “power user” can create an application without having programming skills.
•    It is extensible enough so that a developer can take advantage of it.

As for the cons we can mention the following:
•    A developer is not much attracted to the idea of developing “oriented to data”. They prefer to think in the objects that are part of the business domain regardless of how that will persist afterwards.
•    It is not the best option to build a complex application.

As a conclusion LightSwitch is not the solution for most of the enterprise applications that we tend to develop in Hexacta. Nevertheless, I think that it can be a useful tool to construct small applications that don´t broadly escape from what is a typical ABM, given that they can be done really quickly and extend the model to add business logic in a simple and fancy way.

For more information:

http://www.microsoft.com/visualstudio/en-us/lightswitch

http://msdn.microsoft.com/en-us/lightswitch/gg604823

http://blogs.msdn.com/b/jasonz/archive/2010/08/03/introducing-microsoft-visual-studio-lightswitch.aspx

Follow the red brick path

Ruby on Rails opened a path that other languages didn`t take long to follow: an open-source framework for web applications, whose goal is to improve the productivity and happiness of the developer. Its motto: “Web development that does not hurt”. A framework that is fun to use. A framework that avoids unnecessary configurations. Why do we need them so much? We all know that at the end you end up configuring pretty much always the same things. Following the precepts of convention over configuration, leaving only what s “fun” in hands of the developer and avoiding the “tedious” part of the configuration by accepting the defaults the framework provides.
The Java community was slow to react, Ruby has been around for more than five years, but it slowly began to respond, and many frameworks of the same principle sprung up. These frameworks have the same premise that made the 4th generation languages strong in the nineties: Devote themselves fully to commercial software development, improving developer productivity. But where the 4GL languages focused on abstracting the developer from “low level” issues, these frameworks seek to free the developer from all the configuration responsibilities and make him deal directly with the juicy stuff: the business model, always within the confines of a 3GL language.

The Last Crusade

Grails is a clear example of one of these frameworks, inspired even in the name by Ruby on Rails. Grails is a framework created by the springsource folks for groovy, a dynamic language that runs on the java virtual machine. Grails is a “quick” framework, dynamic and robust. “The search is over” they promise, a clear reference to the crusades and the Holy Grail, and, at the same time, to our search for the framework that allows us to do a web application in just a few minutes.

Jump, little kangaroo!

But Grails still wasn’t Java. It was Groovy. So springsource, once again, came up with a new solution: Spring Roo. What is Roo? Not a framework, not an IDE, but something in between. Spring Roo is a tool that promises quick and easy results when developing web applications. And the most important part: it is pure Java. “Making Java fun” is its motto, prioritizing once again the happiness of the developer. Were we having such a bad time?
Roo allows us to have a running web application written in Java in just a few minutes. Everything is done by working inside an interactive console, with autocomplete and a handy “hint” option, just in case we get lost on how to proceed. As if this wasn’t enough, Roo gives us an offer that is hard to refuse: if at any moment we don´t want to use Roo anymore, we can completely remove it from our application following a few simple steps and everything will keep on working as before. “No lock in” they say, “not married” we would add.
At first sight Roo can scare more than one, too many files are created for each class and it makes extensive use of (for not saying abuse) of aspects. I could even say that it is essential to understand aspects in order to work with Roo, but I wouldn’t go that far. An IDE exists called SpringSource Tool Suite, or STS, that is based on Eclipse and that perfectly integrates with Roo. The STS almost makes us forget about the number of files and the usage of aspects, but sadly it is remarkably slow and that may cause some frustration.
Roo integrates and supports a big amount of technologies, and this list grows every day. Just to give a few examples we can mention Google Web Toolkit, the Google App Engine and several of the Apache and Spring projects. Could this be the main strength of Spring Roo? Could this distinguish it from all the other tools?

Won’t you come out to PLAY?

Looming on the horizon is Play Framework, with a completely different approach, but with the same goal. Play also allows us to code in Java (and pretty soon in Scala) and to forget about the tedious “initial configuration” of every project, but Play is not just another development framework. Play’s strength lies in the fact that it is also an application server, and one made with the idea of developing while having the application deployed. Play provides instant code replacement with no need to restart the server, and it shows errors and stack traces in the browser, so you can see them easily. This feature helps the job of the developer as it prevents losing valuable time while debugging and bugfixing. Something to consider is that Play has some “eccentricities” that will bring headaches to the more “traditional” Java developers, for example the large number of static methods, or the need for public attributes. A different solution for the same problem.

But what if I dislike something about the framework?

What should I do? Each framework has, obviously, its limitations. What would happen if I need to have a service layer? And what if the framework does not encourage it but I really, really, want to use DAO´s? The question we should ask ourselves is: what concessions am I willing to make? Every framework allow us to change something, but not everything can be changed. And that’s when we should make a pause and decide whether we are willing to give up some control of the architecture to the application framework in order to benefit from its advantage, or not. As always, it depends mostly on the problem we are trying to solve.

I consider that, thinking of performance, we should not turn into using many extensions. Below we will recommend ten free and useful plugins for Visual Studio, leaving out the classical plugins or commercial multi-tools such as Resharper, Devexpress Coderush and Visual Asist X.

Documentation: GhostDoc. A widely used extension, documents in XML format, in semi automatic way, facilitating and simplifying this task.

Improvements in the IDE:  VSCommands 2010 provides code navigation and generation improvements which will make your coding tasks faster, together with essentials IDE enhancements, it will take your productivity to another level.

These other extensions had been developed by the Visual Studio team and they are also really useful:

PowerCommands is very light. Adds different funtionalities/ contextual menus, saving time and clicks such as open a Command prompt or the containing folder where one of the files from the solution is located (through a contextual menu) and “Format document on save” that performs the command of “format document” automatically. It has a smart copied of classes and references and, among many others, my favorite command: undo close

Productivity Power Tools: incorporates a series of new functions in Visual Studio such as: improved search, many improvements in the navigation and visualization of the code, adds a better “solution explorer” called Solution Navigator and has lots of changes (several are very useful) in the tabs/navigation of documents.

Code Versioning with SVN: it´s true that we are used to the Visual Studio-Team Foundation Server couple for the versioning of the code, but clearly SVN also is an option and AnkhSVN CollabNET is a fine free tool.

Useless but fun: the Visual Studio Color Theme Editor will not improve any technical aspect, but it allows using predefined graphic themes, changing the whole aspect of visual studio.

Tools for the IDE: we know that sometimes the creation of regular expressions can be an unpleasant job. This tool lets you to perform them in an integrated way in the IDE, simplifying its creation.

Code Comparison: although the beyondcompare is superior, the codecompare is free and tends to be better than the IDEs default tool.

The power of examples: Microsoft All-In-One Code Framework: a code library that provides examples for typical development tasks. Strongly recommended (also has content for VS 2008).

Uses of TFS: for those that use TFS beyond its functionality standard, the TFS power tools 2010 it is already a classic.

Do you have some plugin you would like to recommend? Comment below the post and let  us know!

In this context GIS Systems have been improved in the course of time and they now count with a wide variety of functionalities and complementary tools that make them very powerful. This new capabilities open a new area for their use in applications, though now a days they are not exploited. This lack of use of the new capabilities of GIS Systems is related to the lack of knowledge about the real potential of this systems and the added value they can provide.

From this boom different alternatives emerge, both local and public, from where the developer has to analyze which is the more convenient for the system to be implemented.

Possible uses

Nowadays there are many possible uses for these systems such as:

• Environmental impact

• Addressing to get from one point to another

• Calculations on different terrain elevation

• Mastery of agronomy to maximize the yield of the land

• Support for mobile devices

• Calculate distances and times between points

• Sampling of real-time traffic

• Support for user interaction with the maps

• 3D Views

•Dividing the maps into regions to associate each one with a special behavior. For example, to define regions of the city of Buenos Aires and show the responsible for garbage collection in the different regions of the city.

• Criminology (may be taken as an example the map of insecurity in the province of Buenos Aires)

• etc etc

These are some of the possible uses for which you can use a GIS system and optimize the interaction between the user and the application. To this uses we can add others that meet specific user requirements.

Different Alternatives

Early in this post we mentioned that there are several alternatives in terms of GIS systems. Probably the most known is Google Maps, but also there are other tools that provide a similar service or software packages to have our own GIS server. But…Why having our own GIS server when we have tools that provide the same service such as Google Maps? Basically the answer lies in fact that, if we use our own server, we have complete control of our data (create them, eliminate them and modify them), the services that we can provide and of the maintenance, while with an existing tool we are “limited” to the API they provide for users.

Among the most popular GIS systems we find:

• Google Maps, of Google Inc.
• Bing Maps, la apuesta de Microsoft`s bid
• PostGIS + MapServer + OpenLayers (OpenSource software package that work together to provide a GIS solution)
• SQL Server Spatial

We won’t go into depth in each of these solutions because the objective of this post is to introduce the GIS subject and its benefits when used in commercial applications. Later we will delve into each of these alternatives to present them and provide examples along with the appropriate code to learn more of the potential of each system.

In this way, the national demand for Blackberry equipment will be supplied at first in a 70% by devices produced in Argentina and then will rise to 80% with the incorporation of other models. Blackberry smartphones has the 31% of the local smartphones sales in 2010.
We hope that this fact ends up having positive results since our country makes a big use of mobile devices, especially Blackberry. Considering that the production will be done in Tierra del Fuego, we expect a substantial reduction in the selling price, which makes it much more attractive and also opens the opportunity to export the products to other countries in the south cone.
The global trend indicates that it is important that big mobile companies are encouraged to invest in countries where a good sales strategy is predicted, given that prices for sure will be lower, incrementing in this way the sales. RIM already did this in Malaysia and Brazil so as to open new production routes and now it lands in Argentina with the same purpose and through Brightstar Corporation.
By the end of October we will see the first devices “made in Argentina”. RIM is now part of a group of companies that already installed in Tierra del Fuego such as Sony Ericsson, Alcatel, Motorola, Samsung, LG and Nokia.