Angular 1 and Angular 2 integration the path to seamless upgrade

Originally posted on the Angular blog.

Posted by, Misko Hevery, Software Engineer, Angular

Have an existing Angular 1 application and are wondering about upgrading to Angular 2? Well, read on and learn about our plans to support incremental upgrades.

Summary

Good news!

• Were enabling mixing of Angular 1 and Angular 2 in the same application.
• You can mix Angular 1 and Angular 2 components in the same view.
• Angular 1 and Angular 2 can inject services across frameworks.
• Data binding works across frameworks.

Why Upgrade?

Angular 2 provides many benefits over Angular 1 including dramatically better performance, more powerful templating, lazy loading, simpler APIs, easier debugging, even more testable and much more. Here are a few of the highlights:

Better performance

Weve focused across many scenarios to make your apps snappy. 3x to 5x faster on initial render and re-render scenarios.

• Faster change detection through monomorphic JS calls
• Template precompilation and reuse
• View caching
• Lower memory usage / VM pressure
• Linear (blindingly-fast) scalability with observable or immutable data structures
• Dependency injection supports incremental loading

More powerful templating

• Removes need for many directives
• Statically analyzable - future tools and IDEs can discover errors at development time instead of run time
• Allows template writers to determine binding usage rather than hard-wiring in the directive definition

Future possibilities

Weve decoupled Angular 2s rendering from the DOM. We are actively working on supporting the following other capabilities that this decoupling enables:

• Server-side rendering. Enables blinding-fast initial render and web-crawler support.
• Web Workers. Move your app and most of Angular to a Web Worker thread to keep the UI smooth and responsive at all times.
• Native mobile UI. Were enthusiastic about supporting the Web Platform in mobile apps. At the same time, some teams want to deliver fully native UIs on their iOS and Android mobile apps.
• Compile as build step. Angular apps parse and compile their HTML templates. Were working to speed up initial rendering by moving the compile step into your build process.

Angular 1 and 2 running together

Angular 2 offers dramatic advantages over Angular 1 in performance, simplicity, and flexibility. Were making it easy for you to take advantage of these benefits in your existing Angular 1 applications by letting you seamlessly mix in components and services from Angular 2 into a single app. By doing so, youll be able to upgrade an application one service or component at a time over many small commits.

For example, you may have an app that looks something like the diagram below. To get your feet wet with Angular 2, you decide to upgrade the left nav to an Angular 2 component. Once youre more confident, you decide to take advantage of Angular 2s rendering speed for the scrolling area in your main content area.

For this to work, four things need to interoperate between Angular 1 and Angular 2:

• Dependency injection
• Component nesting
• Transclusion
• Change detection

To make all this possible, were building a library named ng-upgrade. Youll include ng-upgrade and Angular 2 in your existing Angular 1 app, and youll be able to mix and match at will.

You can find full details and pseudocode in the original upgrade design doc or read on for an overview of the details on how this works. In future posts, well walk through specific examples of upgrading Angular 1 code to Angular 2.

Dependency Injection

First, we need to solve for communication between parts of your application. In Angular, the most common pattern for calling another class or function is through dependency injection. Angular 1 has a single root injector, while Angular 2 has a hierarchical injector. Upgrading services one at a time implies that the two injectors need to be able to provide instances from each other.

The ng-upgrade library will automatically make all of the Angular 1 injectables available in Angular 2. This means that your Angular 1 application services can now be injected anywhere in Angular 2 components or services.

Exposing an Angular 2 service into an Angular 1 injector will also be supported, but will require that you to provide a simple mapping configuration.

The result is that services can be easily moved one at a time from Angular 1 to Angular 2 over independent commits and communicate in a mixed-environment.

Component Nesting and Transclusion

In both versions of Angular, we define a component as a directive which has its own template. For incremental migration, youll need to be able to migrate these components one at a time. This means that ng-upgrade needs to enable components from each framework to nest within each other.

To solve this, ng-upgrade will allow you to wrap Angular 1 components in a facade so that they can be used in an Angular 2 component. Conversely, you can wrap Angular 2 components to be used in Angular 1. This will fully work with transclusion in Angular 1 and its analog of content-projection in Angular 2.

In this nested-component world, each template is fully owned by either Angular 1 or Angular 2 and will fully follow its syntax and semantics. This is not an emulation mode which mostly looks like the other, but an actual execution in each framework, dependending on the type of component. This means that components which are upgraded to Angular 2 will get all of the benefits of Angular 2, and not just better syntax.

This also means that an Angular 1 component will always use Angular 1 Dependency Injection, even when used in an Angular 2 template, and an Angular 2 component will always use Angular 2 Dependency Injection, even when used in an Angular 1 template.

Change Detection

Mixing Angular 1 and Angular 2 components implies that Angular 1 scopes and Angular 2 components are interleaved. For this reason, ng-upgrade will make sure that the change detection (Scope digest in Angular 1 and Change Detectors in Angular 2) are interleaved in the same way to maintain a predictable evaluation order of expressions.

ng-upgrade takes this into account and bridges the scope digest from Angular 1 and change detection in Angular 2 in a way that creates a single cohesive digest cycle spanning both frameworks.

Typical application upgrade process

Here is an example of what an Angular 1 project upgrade to Angular 2 may look like.

1. Include the Angular 2 and ng-upgrade libraries with your existing application
2. Pick a component which you would like to migrate
1. Edit an Angular 1 directives template to conform to Angular 2 syntax
2. Convert the directives controller/linking function into Angular 2 syntax/semantics
3. Use ng-upgrade to export the directive (now a Component) as an Angular 1 component (this is needed if you wish to call the new Angular 2 component from an Angular 1 template)
3. Pick a service which you would would like to migrate
1. Most services should require minimal to no change.
2. Configure the service in Angular 2
3. (optionally) re-export the service into Angular 1 using ng-upgrade if its still used by other parts of your Angular 1 code.
4. Repeat doing step #2 and #3 in order convenient for your application
5. Once no more services/components need to be converted drop the top level Angular 1 bootstrap and replace with Angular 2 bootstrap.

Note that each individual change can be checked in separately and the application continues working letting you continue to release updates as you wish.

We are not planning on adding support for allowing non-component directives to be usable on both sides. We think most of the non-component directives are not needed in Angular 2 as they are supported directly by the new template syntax (i.e. ng-click vs (click) )

Q&A

I heard Angular 2 doesnt support 2-way bindings. How will I replace them?

Actually, Angular 2 supports two way data binding and ng-model, though with slightly different syntax.

When we set out to build Angular 2 we wanted to fix issues with the Angular digest cycle. To solve this we chose to create a unidirectional data-flow for change detection. At first it was not clear to us how the two way forms data-binding of ng-model in Angular 1 fits in, but we always knew that we had to make forms in Angular 2 as simple as forms in Angular 1.

After a few iterations we managed to fix what was broken with multiple digests and still retain the power and simplicity of ng-model in Angular 1.

Two way data-binding has a new syntax: [(property-name)]="expression" to make it explicit that the expression is bound in both directions. Because for most scenarios this is just a small syntactic change we expect easy migration.

As an example, if in Angular 1 you have: <input type="text" ng-model="model.name" />

You would convert to this in Angular 2: <input type="text" [(ng-model)]="model.name" />

What languages can I use with Angular 2?

Angular 2 APIs fully support coding in todays JavaScript (ES5), the next version of JavaScript (ES6 or ES2015), TypeScript, and Dart.

While its a perfectly fine choice to continue with todays JavaScript, wed like to recommend that you explore ES6 and TypeScript (which is a superset of ES6) as they provide dramatic improvements to your productivity.

ES6 provides much improved syntax and intraoperative standards for common libraries like promises and modules. TypeScript gives you dramatically better code navigation, automated refactoring in IDEs, documentation, finding errors, and more.

Both ES6 and TypeScript are easy to adopt as they are supersets of todays ES5. This means that all your existing code is valid and you can add their features a little at a time.

What should I do with $watch in our codebase?

tldr; $watch expressions need to be moved into declarative annotations. Those that dont fit there should take advantage of observables (reactive programing style).

In order to gain speed and predictability, in Angular 2 you specify watch expressions declaratively. The expressions are either in HTML templates and are auto-watched (no work for you), or have to be declaratively listed in the directive annotation.

One additional benefit from this is that Angular 2 applications can be safely minified/obfuscated for smaller payload.

For interapplication communication Angular 2 offers observables (reactive programing style).

What can I do today to prepare myself for the migration?

Follow the best practices and build your application using components and services in Angular 1 as described in the AngularJS Style Guide.

Wasnt the original upgrade plan to use the new Component Router?

The upgrade plan that we announced at ng-conf 2015 was based on upgrading a whole view at a time and having the Component Router handle communication between the two versions of Angular.

The feedback we received was that while yes, this was incremental, it wasnt incremental enough. We went back and redesigned for the plan as described above.

Are there more details you can share?

Yes! In the Angular 1 to Angular 2 Upgrade Strategy design doc.

Were working on a series of upcoming posts on related topics including:

1. Mapping your Angular 1 knowledge to Angular 2.
2. A set of FAQs on details around Angular 2.
3. Detailed migration guide with working code samples.

See you back here soon!

Read More..

3 2 1 Code in Inviting teens to contribute to open source

We believe that the key to getting students excited about computer science is to give them opportunities at ever younger ages to explore their creativity with computer science. That’s why we’re running the Google Code-in contest again this year, and today’s the day students can go to the contest site, register and start looking for tasks that interest them.

Ignacio Rodriguez was just 10 years old when he became curious about Sugar, the open source learning platform introduced nationally to students in Uruguay when he was in elementary school. With the encouragement of his teacher, Ignacio started asking questions of the developers writing and maintaining the code and he started playing around with things, a great way to learn to code. When he turned 14 he entered the Google Code-in contest completing tasks that included writing two new web services for Sugar and he created four new Sugar activities. He even continued to mentor other students throughout the contest period.  His enthusiasm for coding and making the software even better for future users earned him a spot as a 2013 Grand Prize Winner.

Ignacio is one of the 1,575 students from 78 countries that have participated in Google Code-in since 2010. We are encouraging 13-17 year old students to explore the many varied ways they can contribute to open source software development through the Google Code-in contest. Because open source is a collaborative effort, the contest is designed as a streamlined entry point for students into software development by having mentors assigned to each task that a student works on during the contest. Students don’t have to be coders to participate; as with any software project, there are many ways to contribute to the project.  Students will be able to choose from documentation, outreach, research, training, user interface and quality assurance tasks in addition to coding tasks.

This year, students can choose tasks created by 12 open source organizations working on

disaster relief, content management, desktop environments, gaming, medical record systems for developing countries, 3D solid modeling computer-aided design and operating systems to name a few.  

For more information on the contest, please visit the contest site where you can find the timeline, Frequently Asked Questions and information on each of the open source projects students can work with during the seven week contest.

Good luck students!

By Stephanie Taylor, Open Source Programs

Read More..

Selection Controls 2 The spinner Control

The spinner controls is similar to the ComboBox in C#. it displays a list to select from in a popup window so ot may become a better choice over ListView if you want to save space.

It works in a similar way to that of the the listView

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
 android_orientation="vertical"
 android_layout_width="fill_parent"
 android_layout_height="fill_parent"
 >
 <Spinner
 android_layout_width="fill_parent" 
 android_layout_height="wrap_content"
 android_id="@+id/Spinner"
 />
</LinearLayout>

when you click on the spinner it popups like this:

To handle the selected item you can use do it like this:

final String [] items=new String[]{"Item1","Item2","Item3","Item4"};
 ArrayAdapter ad=new ArrayAdapter(this,android.R.layout.simple_spinner_item,items);
 ad.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
 Spinner spin=(Spinner)findViewById(R.id.Spinner);
 spin.setAdapter(ad);
 spin.setOnItemSelectedListener(new OnItemSelectedListener()
 {

 public void onItemSelected(AdapterView arg0, View arg1,
 int arg2, long arg3) {
 TextView txt=(TextView)findViewById(R.id.txt);
 TextView temp=(TextView)arg1;
 txt.setText(temp.getText());
 
 }

 public void onNothingSelected(AdapterView arg0) {
 // TODO Auto-generated method stub
 
 }
 
 });

The above code displays the selected item text in the textview.

The parameters of the OnItemClick method are:


• Arg0:the Spinner, notice that it is of type AdapterView.

• Arg1: the view that represents the selected item, in this example it will be a TextView

• Arg2: the position of the selected item.

• Arg3: the id of the selected item.

and thats it for the Spinner Control.

Read More..

A final farewell to ClientLogin OAuth 1 0 3LO AuthSub and OpenID 2 0

Posted by William Denniss, Product Manager, Identity and Authentication

Support for ClientLogin, OAuth 1.0 (3LO¹), AuthSub, and OpenID 2.0 has ended, and the shutdown process has begun. Clients attempting to use these services will begin to fail and must be migrated to OAuth 2.0 or OpenID Connect immediately.

To migrate a sign-in system, the easiest path is to use the Google Sign-in SDKs (see the migration documentation). Google Sign-in is built on top of our standards-based OAuth 2.0 and OpenID Connect infrastructure and provides a single interface for authentication and authorization flows on Web, Android and iOS. To migrate server API use, we recommend using one of our OAuth 2.0 client libraries.

We are moving away from legacy authentication protocols, focusing our support on OpenID Connect and OAuth 2.0. These modern open standards enhance the security of Google accounts, and are generally easier for developers to integrate with.

¹3LO stands for 3-legged OAuth where theres an end-user that provides consent. In contrast, 2-legged (2LO) correspond to Enterprise authorization scenarios such as organizational-wide policies control access. Both OAuth1 3LO and 2LO flows are deprecated, but this announcement is specific to OAuth1 3LO.

Read More..

Reminder to migrate to OAuth 2 0 or OpenID Connect

Posted by William Denniss, Product Manager, Identity and Authentication

Over the past few years, we’ve publicized that ClientLogin, OAuth 1.0 (3LO)¹, AuthSub, and OpenID 2.0 were deprecated and would shut down on April 20, 2015. We’re moving away from these older protocols in order to focus support on the latest Internet standards, OAuth 2.0 and OpenID Connect, which increase security and reduce complexity for developers.

The easiest way to migrate to these new standards is to use the Google Sign-in SDKs (see the migration documentation). Google Sign-in is built on top of our OAuth 2.0 and OpenID Connect infrastructure and provides a single interface for authentication and authorization flows on Web, Android and iOS.

If the migration for applications using these deprecated protocols is not completed before the deadline, the application will experience an outage in its ability to connect with Google (possibly including the ability to sign in) until the migration to a supported protocol occurs. To avoid any interruptions in service, it is critical that you work to migrate prior to the shutdown date.

If you need to migrate your integration with Google:

• Migrate from OpenID 2.0 to Google Sign-in
• Migrate from OAuth 1.0 to OAuth 2.0
• For AuthSub and ClientLogin, there is no migration support. You’ll need to start fresh with OAuth 2.0 and users need to re-consent

If you have any technical questions about migrating your application, please post questions to Stack Overflow under the tag google-oauth or google-openid.

¹ 3LO stands for 3-legged OAuth: Theres an end-user that provides consent. In contrast, 2-legged (2LO) correspond to Enterprise authorization scenarios: organizational-wide policies control access. Both OAuth1 3LO and 2LO flows are deprecated.

Read More..

Basic steps for upgrading source code from SDK 1 5 to 2 1 using Eclipse IDE

This is a step by step guide to upgrade one’s source code that was developed for an earlier version of android SDK, as is to work on a new version of SDK installed on your development environment



Pre-requisites:
1. You are using Eclipse IDE - Ganymede
2. You have installed SDK 2.1 on your machine
3. You have upgraded ADT to 0.96 on Eclipse IDE
4. You have pointed the Eclipse IDE to the new SDK 2.1
5. You have changed the default JDK compiler version on Eclipse to 1.6
6. You have created an Android Virtual Device (AVD) that uses the SDK 2.1 / Google API


NOTE: Upgrading SDK and Eclipse installations itself is provided in detail at http://developer.android.com/sdk/index.html & http://developer.android.com/sdk/installing.html


For each project that you have in your eclipse workspace that was written for the earlier version of SDK, you need to do the following for basic upgrade (this does not include the upgrade of APIs that have be deprecated):

Step-by-step guide
1. Right click the project and go to Project Properties -> Android
2. You wil see tha right pane showing the ‘Project Build Target’
3. In this pane you will see either or both: ‘Android 2.1’ & ‘Google APIs’ depending on what you chose to install when upgrading your ADT to 0.96
4. Select Google ‘Android 2.1’ or ‘Google API” whichever is required by your earlier project (note you might have used only Android 1.5 for most projects. You would need Google API only for those projects that use google maps)
5. Then, go to the ‘Project’ menu and click on ‘clean’. Note, this is an optional step. You may have to do this if you get the error ‘Conversion to Dalvik format failed with error 1’.
6. Then, build the project by going to ‘Project’ -> ‘build’
7. You are done. You can now run the earlier Android application using the new SDK 2.1

Read More..

Chrome Dev Summit Livestream 2015 Day 2

Posted by Paul Kinlan, Chrome Developer Relations

Welcome to day two of the Chrome Dev Summit livestream 2015! Today, we’ll have a full day of sessions covering every aspect of performance on the web. Flipkart will also be joining us on stage later today to talk about their experience building a Progressive web app. Tune in to the livestream below. We look forward to engaging in the conversation with you at #ChromeDevSummit.

Read More..

Web 2 0 for the software services industry

Here are some of my thoughts on what Web 2.0 would mean to the software services industry.

The five main principles that qualify for calling and application / site Web 2.0 is:
1. Web as a Platform and Software as a service
2. Architecture of participation for harnessing collective intelligence
3. Own or create hard-to-recreate data sources
4. Software through multiple channels and devices
5. Rich User interface or Rich Internet Applicaitons

While the principle 2 seems to be attracting the most attention in Web 2.0, for the services industry, principle 1 holds the key.

Let me elaborate what I mean. In terms of implementation, principle 2 stands for creating and enhancing the network of people visiting your applicaitons and using them or adding value to them through blogs, wikis, social networks, susbscription of feeds, provide permalinks and trackbacks, allowing tagging or folsonomy as some call it. Now, providing or building these features is a breeze. Most of them can be just configured by using many available off-the-shelf, open source software.

Also, practically speaking, if an organization does not have a core business around which to implement web 2.0, just providing the above is not going to be of any value add to itself.

The crux continues to remain that any organization must have a core business model that needs to adapt itself to Web 2.0. By this I mean, they must be providing some service in the real world and that should preferrably have already made its presence on the web through the Web 1.0 way. Even if not, it needs to be morphed to be provided as an online service, in the first go.

This is nothing but extending the web service model to the real "web". While the former was more often than not, within the walls of an enterprise or extended mainly to business partners, the latter would be real services maintained for the public use on the web by anyone who subscribes and pays for it. This would mainly help the smaller business of both types: the providers of such services as well as the consumers of such services.

There are enough successful models over the last couple of years like the salesforce.com which are thriving on this business model, a model of revenue generation that did not exist inherently in web 1.0. This may be one of the main causes for a potential success of Web 2.0, as I see it.

Read More..

Introducing gRPC a new open source HTTP 2 RPC Framework

Today, we are open sourcing gRPC, a brand new framework for handling remote procedure calls. It’s BSD licensed, based on the recently finalized HTTP/2 standard, and enables easy creation of highly performant, scalable APIs and microservices in many popular programming languages and platforms. Internally at Google, we are starting to use gRPC to expose most of our public services through gRPC endpoints as part of our long term commitment to HTTP/2.

Over the years, Google has developed underlying systems and technologies to support the largest ecosystem of micro-services in the world; our servers make tens of billions of calls per second within our global datacenters. At this scale, nanoseconds matter. Efficiency, scalability and reliability are at the core of building Google’s APIs.

gRPC is based on many years of experience in building distributed systems. With the new framework, we want to bring to the developer community a modern, bandwidth and CPU efficient, low latency way to create massively distributed systems that span data centers, as well as power mobile apps, real-time communications, IoT devices and APIs.

Building on HTTP/2 standards brings many capabilities such as bidirectional streaming, flow control, header compression, multiplexing requests over a single TCP connection and more. These features save battery life and data usage on mobile while speeding up services and web applications running in the cloud.

Developers can write more responsive real-time applications, which scale more easily and make the web more efficient. Read more about the features and benefits in the FAQ.

Alongside gRPC, we are releasing a new version of Protocol Buffers, a high performance, open source binary serialization protocol that allows easy definition of services and automatic generation of client libraries. Proto 3 adds new features, is easier to use compared to previous versions, adds support for more languages and provides canonical mapping of Proto to JSON.

The project has support for C, C++, Java, Go, Node.js, Python, and Ruby. Libraries for Objective-C, PHP and C# are in development. To start contributing, please fork the Github repositories and start submitting pull requests. Also, be sure to check out the documentation, join us on the mailing list, visit the IRC #grpc channel on Freenode and tag StackOverflow questions with the “grpc” tag.

Google has been working closely with Square and other organizations on the gRPC project. We’re all excited for the potential of this technology to improve the web and look forward to further developing the project in the open with the help, direction and contributions of the community.

Post by Mugur Marculescu, Product Manager

Read More..

Smaller Fonts with WOFF 2 0 and unicode range

Posted by Rod Sheeter, Software Engineer

The Google Fonts and Chrome teams are constantly looking for ways to make fonts better for online content. In 2014, we deployed two big optimizations: WOFF 2.0 and unicode-range. Combined, they are reducing the size of the downloaded fonts by more than 40 percent on average. For users, that means faster download times and lower data costs!

The HTTP Archive has a graph of observed font sizes across the web, primarily in WOFF format. If we compare this to our best estimate of the savings attributable to WOFF 2.0 and unicode-range optimizations that went live in 2014, it looks like this:

WOFF 2.0 is a new font format using a new compression algorithm, Brotli, created by the Google Compression team. WOFF 2.0 responses use ~25 percent less bytes than WOFF with Zopfli.

unicode-range allows the browser to automatically select what subset(s) of the font it needs based on the particular font glyphs used on the page. In practice, we’ve observed approximately 50 percent reduction in response size on some large sites with this optimization. On average, we see unicode-range responses use ~20 percent less bytes than they would without.

So, how do you take advantage of these optimizations? The great news is, if you are using Google Fonts on your site, than you are already taking advantage of these optimizations! We’ve already done all the work to enable both WOFF 2.0 and unicode-range support for browsers that support it (see caniuse.com/woff2, caniuse.com/unicode-range) on your behalf. It’s that easy.

If you are using a different provider, or hosting the fonts yourself, then you will have to do a little bit of work to enable these optimizations:

To use WOFF 2.0, convert your fonts using a supporting editor or via the command line tools and either serve WOFF 2.0 only to supporting browsers (what we do at Google Fonts), or use a bulletproof font-face declaration similar to the following (courtesy of Font Squirrel, with svg removed):

/* Generated by Font Squirrel (http://www.fontsquirrel.com) on February 2, 2015 */
@font-face {
 font-family: lobster;
 src: url(lobster-webfont.eot);
 src: url(lobster-webfont.eot?#iefix) format(embedded-opentype),
 url(lobster-webfont.woff2) format(woff2),
 url(lobster-webfont.woff) format(woff),
 url(lobster-webfont.ttf) format(truetype);
 font-weight: normal;
 font-style: normal;
}

To use unicode-range, the story is a bit more complicated. Due to inconsistent behavior of some older browsers, which will download all subsets regardless of whether they are required, you should serve unicode-range property only to browsers that support it fully. With that in place, cut your font into pieces as you see fit (Google Fonts uses fontTools for this), and serve multiple @font-face rules, one for each segment. You can see an example of this by looking at the CSS generated by Google Fonts for a browser which supports these features (e.g. access http://fonts.googleapis.com/css?family=Lobster with Chrome).

For more tips on optimizing your fonts, see Ilya Grigorik’s Optimizing Web Font Rendering Performance. If you try any of this let us know how it works out @googlefonts!

Read More..

GameSave Elementalist v1 0 2

Application Name: Elementalist
Current Version: 1.0.2
iTunes Url: https://itunes.apple.com/us/app/id742844061?mt=8
Free
Size: 70.0 MB

free for Non-Jailbroken and Jailbroken.

• 955,000,555 Coins
• Unlock Counterfeit Machine
• Unlock No more barriers!

Read more »

Read More..

GameSave Hired Gun 3D v1 2 1

Application Name: Hired Gun 3D
Current Version: 1.2.1
iTunes Url: https://itunes.apple.com/us/app/id452658786?mt=8
Free
Size: 82.5 MB

GameSave for Non-Jailbroken and Jailbroken.

• 955,000,555 Cash

Read more »

Read More..

Zombie Kill of the Week v1 2 4

Application Name: Zombie Kill of the Week
Current Version: 1.2.4
iTunes Url: https://itunes.apple.com/us/app/zombie-kill-of-the-week/id633274050?mt=8

free for Non-Jailbroken and Jailbroken.

-- 955,000,555 ZKW-Points

Read more »

Read More..

SugarSync v1 0 2 for Symbian S60 3rd and 5th Edition and Symbian 3 Free App Download

SugarSync v1.00(2) for Symbian features the ability to remotely access, open and easily share files via your mobile phone, including documents, photos and more stored in a SugarSync account. Plus, with an appropriate document editor, files can be edited and synced back.

SugarSync v1.00(2)

Read more »»

Read More..

Python SDK version 1 2 2 released

Weve released version 1.2.2 of the App Engine SDK for Python. Some highlights from the release notes:

• 
  Urlfetch fetch now has support for user configurable deadlines.
  
• 
  Datastore indexes on single properties can now be disabled by setting indexed=False on the property constructor.
  
• 
  Datastore now supports Key-only queries, using either SELECT __key__ or db.Query(Model, keys_only=True)
  
• 
  Bulk Loader improvements: New appcfg download_data command. Better backoff support and debugging output for long requests.
  

For a full list see the SdkReleaseNotes wiki page.

Downloads for Windows, Mac, and Linux are available on the Downloads page. This SDK update was for the Python runtime, so please post your feedback in the Python runtime discussion group.

Read More..