A new framework in mobile application development

Flutter is Google’s mobile UI framework for crafting high-quality native interfaces on iOS and Android in record time. Flutter works with existing code, is used by developers and organizations around the world, and is free and open source. It’s not necessarily a household name yet, but it’s also less than a year old and, to some degree, it’s going up against frameworks like Facebook’s popular React Native. Google’s framework, which is heavily focused around the company’s Dart programming language, was first announced at Google’s I/O developer conference last year.

As the company announced today, Flutter is now officially in beta and a number of developers have already used it to build and publish apps that have hit top spots in both the Google Play and Apple App Store.

As per Techcrunch Latest Articles

Seth Ladd, Google’s product manager for Flutter, told me that it’s no surprise that the company is making this announcement during MWC. The company wants to use this opportunity to engage with mobile developers and to highlight the advances it made over the course of the last year. For the most part, that means better tooling, like support for Android Studio and Visual Studio Code for writing Flutter apps.

Key Features of List

Fast DevelopmentHot Reload in milliseconds to paint your app to life. Use a rich set of fully-customizable widgets to build native interfaces in minutes.
Expressive and Flexible UIQuickly ship features with a focus on native end-user experiences. Layered architecture allows full customization, which results in incredibly fast rendering and expressive and flexible designs.
Native PerformanceFlutter’s widgets incorporate all critical platform differences such as scrolling, navigation, icons and fonts to provide full native performance on both iOS and Android.

Why Dart is the just the right language for Flutter?

“We didn’t find another language that hit this sweet spot of fast development cycle plus the standard stuff devs expect and love like object orientation, a rich core library and very easy onboarding. With this beta, Flutter now supports the pre-release version of Dart 2, which offers better support for client-side development, too.

What about rival frameworks like React Native?

Flutter uses its own GPU-accelerated graphics and rendering engine and not a web view. “There is a huge benefit to this in that the design that your designers envision and what they delivered to your developers are the exact some pixels and designs that your users will experience,” said Ladd. “By shipping our own graphics engine, we offer consistent design as your designers envisioned.”

The Flutter team also stresses that Flutter plays nice with existing parts of an app. You don’t need to write your complete app in Flutter. Indeed, many of the developers that have already used it have simply added new Flutter-based screens to their existing apps. As for apps that are fully based on the new toolkit,Google notes that the Hamilton app is among the most popular app to have been built with Flutter.

Expressive, beautiful UIs

lutter’s built-in beautiful Material Design and Cupertino (iOS-flavor) widgets, rich motion APIs, smooth natural scrolling, and platform awareness.

 

 

Power of new API lang GraphQL

Here I have picked one of most interesting topic for API development. From many year, we are developing an API in two Protocols REST and SOAP and most of time developers are preferred REST, because of its simplicity and easy to handle in APPS’. But last many days I have seen a new Query language with more simple and fast as compared to REST and it is graphical query lang.(GraphQL).

Introduction

GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.

What Is GraphQL?

GraphQL is an application layer query language that interprets a string by a server, which then returns the required data in a specified format. Open sourced by Facebook in 2015, GraphQL was developed internally during the transition from Facebook’s HTML5-powered mobile apps to native apps. Today it is the principle graph data query language powering the majority of interactions within iOS and Facebook Android applications. Anyone that has used native iOS or Android apps during the past two years has used GraphQL-powered apps.

The creators of GraphQL plan to open-source an instruction program on how to implement the server. The goal is to expand GraphQL capabilities to adapt to a wide range of backends. This will allow coders to use the technology in projects of any size to access their own data more efficiently. Product developers will be able to structure servers and provide powerful frameworks, abstractions and tools.

What You Can Do With GraphQL

GraphQL is a very liberating platform. With GraphQL, product developers no longer need to contend with ad hoc endpoints or worry about accessing data with multiple roundtrip object retrievals. Instead, you can easily create an elegant, declarative-hierarchical query dispatched to one single endpoint. You no longer have to jump back and forth from client to server development environments to test new codes or to create views of data already entered. Now all your experimentation and newly created views are built exclusively in the client development environment. The hassle of moving unstructured data from ad hoc endpoints into business objects is eliminated. Instead, you get a powerful, intuitive type system you can use as a tool-building platform.

How GraphQL Is Different

The GraphQL query language is positioned between client applications and the actual data sources. Think of it as a type of agreement between the client and the server with an efficient query and fetching system. It works independently from data sources and other platforms. A GraphQL server can be created in PHP, Node or any other platform of your choice. People should be able to connect to your GraphQL server with web apps, mobile apps or any other type of apps they may be using. They can then query and mutate the data they are looking for.

It has very interesting feature and I have mentioned the list.

Ask for what you need,
get exactly that
Send a GraphQL query to your API and get exactly what you need, nothing more and nothing less. GraphQL queries always return predictable results. Apps using GraphQL are fast and stable because they control the data they get, not the server.
Get many resources
in a single request
GraphQL queries access not just the properties of one resource but also smoothly follow references between them. While typical REST APIs require loading from multiple URLs, GraphQL APIs get all the data your app needs in a single request. Apps using GraphQL can be quick even on slow mobile network connections.
Describe what’s possible
with a type system
GraphQL APIs are organized in terms of types and fields, not endpoints. Access the full capabilities of your data from a single endpoint. GraphQL uses types to ensure Apps only ask for what’s possible and provide clear and helpful errors. Apps can use types to avoid writing manual parsing code.
Evolve your API
without versions
Add new fields and types to your GraphQL API without impacting existing queries. Aging fields can be deprecated and hidden from tools. By using a single evolving version, GraphQL APIs give apps continuous access to new features and encourage cleaner, more maintainable server code.

Improvements to the Customize JS API in 4.9

A Customizer is the one of the greatest feature of WordPress. Not only it is simple to handle WordPress site but also it resolved many pointer for developers. But in previous versions developer faced many issue. which are improved in 4.9, including: drafting/scheduling of changesets, autosave revisions, changeset post locking, frontend public previews, a new experience for browsing and installing themes, updated nav menu creation UX, and the code editing improvements for the Custom HTML widget and Additional CSS. But in addition to all of these, there are also many improvements for developers which will make extending the Customizer much more pleasant.

Something important to remember about the Customizer is that it is a single page application that is powered by JavaScript. Many developers may only interact with the PHP API for registering controls, settings, sections, panels, and partials. But controls, sections, and panels do not need to be registered in PHP at all. The PHP API for registration is essentially a wrapper for the underlying JS API. When you load the Customizer all of the params for the PHP-registered constructs are exported to the client for the JavaScript API to instantiate and initially add to the UI, but this JS API can dynamically instantiate additional constructs at any time thereafter in a Customizer session. This is how new widgets, nav menus, and nav menu items are added without requiring the entire Customizer to reload. You can also avoid statically registering settings and partials in PHP by instead adding filters to dynamically recognize settings and partials, allowing them to be registered on demand. All of this allows the Customizer application to scale out to be able to customize and preview an unlimited number of things on a site (e.g. any post or page with their postmeta in the Customize Posts feature plugin). The point here is that in order for the Customizer to scale, the JavaScript API must be used directly. So this is why the Customizer JS API improvements in 4.9 are important as they fix many longstanding annoyances and shortcomings with the JS API.

This dev note contains the following sections:

From above mentioned pointers I like Control Templates feature. Let’s us what new happened in it..

Control Templates

Refer back to the “Pane Width” example above where a type of number was supplied when constructing a base wp.customize.Control class. This would not work prior to 4.9 because there were no content templates defined for base control types. This is no longer the case with the resolution of #30738. If you construct a control and supply a type param that corresponds to an HTML5 input type, then the default control template will be used to render the control. Note that for color inputs, one should use the dedicated ColorControl.

A control’s template is normally derived by its type; for instance, a Background Position control has a type of background_position and then has a wp.template ID of customize-control-background_position-content. The template is normally output by a control’s WP_Customize_Control::content_template() template after the control has been registered via WP_Customize_Manager::register_control_type(). In 4.9 however, this can all be bypassed as controls now understand a templateId param.

An example of supplying an ad hoc templateId when constructing a control can be seen in the changeset status control, where it overrides the template used for this one radio control instance:

var statusControl = new api.Control( 'changeset_status', {
    priority: 10,
    type: 'radio',
    section: 'publish_settings',
    setting: api.state( 'selectedChangesetStatus' ),
    templateId: 'customize-selected-changeset-status-control',
    label: api.l10n.action,
    choices: api.settings.changeset.statusChoices
} );
api.control.add( statusControl );

Alternatively, if you have a custom control that you always want to have a specific template (as when calling WP_Customize_Manager::register_control_type() in PHP), you can now do this entirely in JS by adding templateId to the control subclass’s defaults, as can be seen in the PreviewLinkControl:

var PreviewLinkControl = api.Control.extend({
   defaults: _.extend(
      {},
      api.Control.prototype.defaults,
      {
         templateId: 'customize-preview-link-control'
      }
   )
   /* ... */
});

For some more examples, see answer on the WordPress Development Stack Exchange.

Speaking of WP_Customize_Manager::register_control_type(), the types for panels, sections, and controls now are all registered before the customize_register action is triggered. This means that if you have a plugin that unregisters all customize_register actions in order to create a “blank slate” plugin-specific Customizer, you no longer have to re-register these types to be able to use them.

Dropbox URL tip & tricks

Did you know that when you send someone a Dropbox link to a file that you want them to download that it takes them to Dropbox online and they have to take a few more steps to download it?

Well…it does.

So, when you provide a link like this:

https://www.dropbox.com/s/72go9jvokudsidb/gmailextensions.pdf?dl=0

which is the link you get when you ask to “copy dropbox link” within your dropbox account, it takes them to a screen that looks like this (obviously YOUR file will be in the place of where mine is right now).
They then have to click the link at the top to download it. So it’s more work for them, which can be super annoying.

Another reason this is not so great is because there are some people who don’t have a Dropbox account and/or hate it – so they’ll get a notification that Dropbox wants them to create an account and they’re not going to like that much (not that they HAVE to but it could be annoying).

So, there’s a solution.

All you have to do is change the “0” at the VERY END of your Dropbox link to a “1”.

Yes, that’s it.

So instead of this https://www.dropbox.com/s/khq6f4ju732la2p/Screenshot%202016-03-30%2014.22.39.png?dl=0

You’d have something like this https://www.dropbox.com/s/khq6f4ju732la2p/Screenshot%202016-03-30%2014.22.39.png?dl=1

“Then what happens?”, you ask.

Render a file in a browser directly
Some browsers aren’t configured to correctly preview files. While certain file types can be downloaded instead of opened, others—like HTML—are not supported.

To bypass the preview page and allow your browser to directly render your files, use raw=1 as a query parameter in your URL. Adding raw=1 to a URL will cause an HTTP redirect. If you’re an app developer using such a URL in your own code, please make sure your app can follow redirects as well.

Keep a Downstream git Repository Current with Upstream Repository Changes

Git is a very wonderful and revision management system as we all developer know it. Git has itself an advance level bus architecture. Today Git is very useful for every IT industries they are using it very frequently. But still Git has hold many hidden features, which we have not know yet. So today I am going to share one of them.

It is Upstream and Downstream. Before trying to understand what the upstream tracking branch is, you need to be familiar with remote branches (e.g. origin/master). If you are not, you probably want to read the section about them in the Pro Git book here.

To see all your remote tracking branches, you can use

git branch –remotes

The upstream tracking branch

Even if you have never heard of the concept, you probably already have at least one upstream tracking branch: master -> origin/master. When you clone a repository the current HEAD (usually ‘master’) is checked out for you, but also, it’s setup to track ‘origin/master’, and thus ‘origin/master’ is the “upstream” of ‘master’.

This has some implications on some Git tools, for example, when you run ‘git status‘ you might see a message like this:

# Your branch is behind 'origin/master' by 1 commit.

Also, if you run ‘git branch -vv‘:

* master 5002ca22 [origin/master: behind 1] Add bash_profile

This is useful in order to keep your local branches synchronized with the remote ones, but it’s only scratching the surface.

Problem

A downstream repository (aka a “fork”) maintainer commonly needs to stay current with upstream work. The following steps allow you to achieve this on the command line in a local git repository.

Steps

Add the Remote Upstream Repository

This step defines the upstream repository of your fork.

$ git remote add upstream [Upstream git URL]

Fetch the Upstream Branches

$ git fetch upstream

Merge Upstream Changes into your Downstream Repository

From your master branch, use the following merge command to merge the upstream master branch changes into your local source:

$ git merge upstream/master

Create a New Branch for Work

Create a branch off of the master branch that will include the new work. While working in the master branch, execute the following (with any appropriate branch name in quotes):

$ git checkout -b "feature-new-stuff"

Here, we defined the branch feature-new-stuff and will perform work there.

Perform Your Local Work

Follow the standard local repository workflow of file changes with git add . git commit steps for the files.

Push Changes to Your Downstream Remote Repository

When you are ready to push changes to your remote fork of the upstream repository, use the following:

$ git push origin feature-new-stuff

Your local and remote downstream repositories are now current with your local feature-new-stuff changes and this branch is current with the upstream repository changes as of the time of the merge step above.

Google and Salesforce partnership

Finally, world top two companies unveil partnership done. Each of them is knowing as its best product and those are no need any kind of identification. Their product collaboration not only increases the user ability but also customer product rating itself. Huh, Yes you’re correct I’m talking about Google and Salesforce’s partnership. Some day ago I have heard this news that “Google and Salesforce will thing about the partnership” but as per today TechCrunch news both companies did it. Now User can use its Google analytics data with Salesforce CRM to judge their product value itself.

It is not only with Google Analytics soon you can use other Google product’s with salesforce and i.e Google BigQuery, Google’s data warehouse service as well. So here I would like to share why Salesforce’s thing about this partnership and its strategy as per its blog.

Actually, Salesforce main focus is on delivery the most efficient and reliable thing to its customer. So that Salesforce decided multi-vendor approach which is not only but also best for the customer base. As we know AWS and Google both have lots of data which cloud or order delivery service. So as such type partnership will help them for their product value calculation and money.

How Does it will Support?

After this collaboration, customers will be able to surface powerful customer intelligence seamlessly between G Suite, which is already being used by more than 3.5 million businesses globally, and Salesforce Lightning and Quip, which are redefining CRM for the Fortune 500. And with the Salesforce integration with Google Analytics 360, the first time Google Analytics has integrated with a third party, customers will have incredible insights to deliver the most relevant experience at the right moment.

What thing will we get after this unveils partnership?

  • The companies will offer new integrations that connect Salesforce, the world’s #1 CRM platform, with G Suite, Google’s transformative productivity and team collaboration services, enabling customers to surface powerful customer intelligence seamlessly between Salesforce Lightning and Quip and Gmail, Hangouts Meet, Google Calendar, Drive, Docs and Sheets. To enable Salesforce’s more than 150K customers with no charge for up to one year (restrictions apply, see here).
  • The companies will also deeply integrate Salesforce with Google Analytics, seamlessly connecting sales and other’s as well.

That such, first step in a much broader partnership between the two companies and they promise much deeper integration over the coming year including bringing in product specific data and lifetime customer value.

Designer & Developer Collaboration

Android App development is today key of the market. There are huge kinds of applications available in a market as per your requirement. But usability of application depends on two things one is its Ui/Ux and second is the performance. As the designer is designing such as fascinating designs for apps. But after that designer need help to developer also for its slicing and further things as such as res icons/images. A designer who designs the app screens as such like app concept and developer will make it feasible for market/ clients as its requirements.

But in that case, designer work is double because he/she need to provide res as per developer requirement. But here we have a very effective tool which will help us to do it very easily and it is totally free. You never need to pay any extra for this.

Zeplin is the key to unlock this thing. It is available for two operating system environments one is mac and another one is windows and for Linux, it is available but with limitations.

Installing Zeplin

Zeplin is a collaboration tool between Designers and Developers. Designer can upload the designs directly on to Zeplin and it generate style-guides and assets, automatically. Usually, developer requests the designer for resources in multiple resolutions for multiple drawable dimensions. This process can be made automatic as Zeplin can generate the drawables for you.

a. Download and Install Zeplin. Alternatively you can use Zeplin’s web interface by signing into their website.

b. Once installed, login with your Zeplin credentials.

Importing the Project into Zeplin

Once you are done with design part, you can start exporting the project into Zeplin and check if everything is properly done.

a. Create a new project in Zeplin by navigating to Project ⇒ New Project, select Android as we have designed the android app. Give your project a name on the right sidebar.

b. Open designing app and Select the Art board folder on the left sidebar.

c. Goto Plugins ⇒ Zeplin ⇒ Export Selected Artboards. This will open Zeplin again.

d. On Zeplin, select the project you want the screen to be imported. It will start uploading the assets. Once done, you can see the screen on Zeplin’s dashboard.

Exporting App Assets from Zeplin to Android Studio

Zeplin has the intelligence to detect the elements on the document and provide styles-guides like font size, family, color and even gives you code suggestions needed for Android. It also generates the images into multiple dimensions required for Android development. All the images will be organized into drawable-xx folders, so you can directly add them to your android project.

a. In order to download the assets, you need to make them exportable using Slice tool in Sketch. To export the drawable, select the image and click on download button next to png assets on the right sidebar.

b. Select the path to your Android Project’s res folder and click on Export. This will place all the images into proper drawable-xx dimensions.

c. If you select labels, you can see the style-guides like font size, family, color and Android code suggestionson the right sidebar. You can directly add the code to your xml layouts.

I hope this article gave you good information to get started with android UI design. If you have any queries, please comment.