Understanding JavaScript Data Types and Variables

October 17, 2018 Posted by News, Programming 0 thoughts on “Understanding JavaScript Data Types and Variables”

Welcome, Fresh Coders!

If you’ve ever had the pleasure(or displeasure)of sitting through an Algebra 1 class, you’ve probably heard about variables. You know, x + 4 = 6 and all that good stuff. Don’t worry. JavaScript variables are much less scarier. You get to declare them so that you know exactly what they are. And, for the love of all that’s holy, don’t name your variables x or y or z. Give them reader-friendly names so that you’re not staring at a quadratic equation by the time you’re finished coding.

First, before we start messing around with variables and learning what variable deceleration even means, let’s learn to need them. By that I mean let’s get a little cozy with operators and data.

Data Types

Open up your Twitter or Instagram account and you’re hit with a log in screen prompting you to enter your information. When you enter your username and password, you’ve just entered data. You fill out a survey, you like a post, you order ten fidget spinners on Amazon — all of that is data.

In JavaScript, this data is divided into three groups:

1 ) Numbers

Numbers are exactly what you’ve known them to be all your life — 1, 50, 22.3, 5…Integers, decimals, fractions.

JavaScript is real friendly when it comes to numbers, because you don’t have to specify the type of number. We call this behavior untyped. JavaScript is untyped because determining whether a number is an integer or a decimal(float) is taken care of by the language’s runtime environment.

Why don’t you try entering typeof 5 into the editor and hit the run button. You should get 'number'.

Pro tip: typeof 5 is called a statement. You wrote JavaScript code and expected to get a value in return.

2) Strings: “Hello there”

Strings are simply fields of text. Even the words you’re reading now form a string. To encase these words, we use quotes. Keep in mind that strings aren’t limited to run-on sentences.

In JavaScript, this is also a string: "123";

typeof "1,2,3";
typeof "hello world";

You can probably guess by now that your passwords are stringy bytes of data.

3) Boolean: True, False

Don’t let the name throw you off. It’s the namesake of the mathematician George Bool. Booleans only have two values: true and false.

typeof true;
typeof false;

As you’ll come to know, these are important values when it comes to adding logic to our programs.With just those two values, you can create a complex system of loops and conditions.

But let’s not get ahead of ourselves. We will explore the depths of conditions and loops another time.

For now, let’s move onto what makes all of this data worthwhile.

Operators

What’s the use of data if you can’t do anything to it? That’s where operators come in. Each data type (Numbers, Strings, Boolean) share a set of operators that you can use to come up with nifty solutions to problems. There are four important categories of operators that you’ll use throughout your time as a JavaScript developer and they are

1)Arithmetic Operators

addition +

Number:1234 + 4579;

String:"hello" + "Jerry";

Yes, you can add a string. There’s a fancy term for this called string concatenation. Notice how the two strings glob together. We can solve this problem by adding an empty string in between.

"hello" + " " + "Jerry";

Boolean: true + false;

Performing arithmetic operations on boolean values actually returns a value. In this case, the value 1 isn’t just any ordinary 1. It’s a bitwise 1. In the language of computers, this translates to true. So, we can conclude that true plus false equals true.

Why is that so? You’ll understand once we turn true and false into what our computer actually sees.

computer:
true: 1, false: 0
result:
1 + 0 or 0 + 1 = 1

subtraction –

Number:1234 - 1234;
String: NaN Note: NaN(Not a Number) is the error you’ll get when you try to subtract String values.
Boolean: true - false; or false - true;

division /

Number:1234 / 1234;
String: NaN
Boolean: true / false; or false/true;

multiplication /

Number:1234 * 1234;
String: NaN
Boolean: true * false; or false * true;

modulo %

This cool operator tells us the remainder of a division of two values.

Number: 10%3;String: NaNBoolean: true % false; or false % true;

Increment ++

++ is a fancy way to say add 1 to any value. It matters where you put the incrementer. Oh, and by the way, we need variables now. JavaScript’s interpreter can’t read ++10 if 10 is not saved inside a variable. why? Because plus, plus is what we call syntactic sugar. It’s something that was created to make life easier for developers, because it turns out we’re pretty lazy. Instead of saying 10 + 1, we get to forgo adding the 1. Since plus,plus is technically not a real arithmetic operator, you need to define a variable so that you won’t get errors.

Before we start our lesson on variables, try playing around with them. Type this into a code editor:

var cookies = 5;
console.log(cookies++); > 5
console.log(++cookies); > 7

The variable names are arbitrary. You can name them whatever you like. As we’ll explore later, it’s best to name them appropriately.

Pro tip: var cookies = 5; is called an expression. You defined what value cookie has but you didn’t ask for its value. As you learned earlier, this would be a statement: cookies;

Note: console.log() is a web tool that prints JavaScript code to a console. Every web browser has a console you can access. This “web tool” is really called a Web API. It’s much easier to think of API’s as a set of tools that make your job a whole lot easier.

So…why are we not getting the values we expect???

Well, writing the variable before ++ gives us the original value before it can be incremented and vice versa.

Think of it this way: we asked the baker for 5 cookies before he knew we wanted to add one more to the order(cookies | ++).

We receive a receipt saying we ordered five, but when we ask for one more, the baker runs back to get us one more(so, we have 6 cookies now).

The baker returns, but we ask for one more again(++ | cookies).

Finally, when we ask for our cookies, our total is 7 cookies.

JavaScript’s interpreter is that poor baker when it comes to incrementing and decrementing.

decrement — –

Number: -- number

String: NaN
Boolean: --true

+= Plus Equals, and -= Minus Equals, and *= Times Equals, and /= Divided Equals

It turns out programmers are lazier than you thought. Yes, there are more arithmetic shortcuts.

Say you have var score = 5; and, instead of incrementing score by 1, you want to increment it by 6.

Normally you’d write score = score + 6;

With Plus Equals you simply have to write it as score += 6;
Why don’t you try it out with different operators?

2. Comparison Operators

logical operators return true or false. Without them, we wouldn’t have all of the apps that are available to us.

operators

equals ==
not equal !=
greater >
less <
greater/equal< =
less/equal> =

There’s also a special triple equals(===). This checks to make sure that the types are the same as well.

Try this out: 3 == '3';. You got true, right? The fact that JavaScript ignored our stringed ‘3’ can cause some unwanted bugs. To fix this, add another equals. Now you should get false. That’s because triple equals also ensures that the types are exactly the same as well.

Operators are useful for conditional logic. Let’s use an if/else statement to test out an equals operator.

If ('you feel overwhelmed by this new topic'){
 'Do not worry. Sometimes the best way to learn is to try and fail'
}else {
 'Let's get this show on the road!'
}

Try this real if/else statement.

if(2==3){
 console.log('correctomundo');
}else {
console.log('wrooong');
}

Note: the end of if statements don’t receive semi-colons. Here’s a pro tip: Exclude them from any statements or expressions ending in a bracket.
Be sure to use different data types in your if/else statement. You can even play around with all of the operators you’ve learned so far.

3. Logical Operators

Logical and &&, Logical or||, Logical not !

Logical operators allows us to add complexity to our conditional statements. Practically, if you want maximum control over a condition, you’d use && because all of the conditions must be met in order to be true. Conversely, if you want the condition to be more inclusive, you’d use || because only one condition has to be true to get a return value of true.

if(2==2&&3==3&&3==2){
 console.log('correctomundo');
}else {
console.log('wrooong');
}

Variables, Finally!

So, you were introduced to variables prematurely. Even then, you saw how badly we needed a variable in order to get the increment and decrement operator working.
Now, let’s think of numbers, strings, and booleans as Snap chat photos that ghost away after a short period. They don’t stay around long enough to be useful. If you want to use the same data, you’d have to re-type it somewhere else in your JavaScript file.

Imagine having to write this formula over and over again: 1/2(60 * 120);

Or this really long string: "superkalafragilisticespialadocious";.

What a variable does is allow us to save data so that we can use it again.
Let’s declare two variables

var triangleArea, poppinsQoute;

Now for some takeaways:

The var keyword creates what’s called a global variable. It’s like taking a shower in public. Everyone can see you. In JavaScript, we have blocks, like neighborhood blocks. Within our if/else statements, we wrote a block of code that only ran based on certain conditions. Those two variables can be accessed within that block, because we declared them in a global scope.

Think of scope as perspective. From the perspective of the outside, we can’t always see what is inside someone’s house. But from the inside, we can see everything that’s outside.

We shouldn’t be able to look inside an if/else statement and see its local variables. Local variables are variables that are declared within a block.
pro tip: any code within curly braces form a block.

if(3==3){
 var number = 3;
}

Notice the assignment operator. In this example, I’ve declared and initialized my variable at the same time. The equals sign in this case is not the same as the equal sign you use in math. It simply means that you want to assign particular data to a variable you made up. The operator used is called an assignment operator.

Alright. Remember what I mentioned about global and local variables. You’re probably guessing that if I were to use this variable outside of the block, we should get an error.

if(3==3){
 var number = 3;
}
console.log(number);

Wait…we were still able to access the variable outside of the block. Did we just acquire X-Ray vision? So all this talk about local and global variables must be a lie then, right?

Well, the problem with the var keyword is that it loves to expose itself in public. Even if it’s defined within a block, it’ll still want to be seen by everyone. The only thing that can tame it is a function.

function test(){
  var number = 3;
}
console.log(3);

We will get into functions another time, but all you need to know for now is that functions create their own scope. They’re like highly secured mansions.
That’s all fine and dandy that functions are so secure, but how do I secure an if/else statement?

There is a new way to declare variables as of Es6. Every so often Ecma International comes up with new ways for us to code in JavaScript. What they’ve come up with to solve this issue is the let keyword.

Let’s use it!

if(3==3){
 let number = 3;
}
console.log(number);

Great. Now we truly have global and local variables.

Going back to our original variable declarations, var triangleArea, poppinsQoute;, you can see that we are able to declare multiple variables at the same time by separating them with a comma. Also, look at how the second word in the variable name starts off with a capitalized letter. This convention is called camel case. It’s good to stick to this convention so that your code is legible to you and to others that might look at your code one day.

The Variable Warehouse

We’ve messed around with variables a little, but we haven’t pushed them to the limit. Let’s see what we can put inside of a variable.

numerical statement

triangleArea = 1/2(60 * 120);

strings

poppinsQoute = "superkalafragilisticespialadocious";

boolean

let true_ = true;

Wait. Why the underscore? See, you can’t name a variable anything that is already named by those who’ve designed the language. Just make sure that you don’t start naming your variables with numbers: 123true.

logical statement

let check = (2==2&&3==3&&4==4);

The parenthesis is there for readability. You can plug this right into your if statement and it’ll work beautifully.

if(check){
 console.log("true");
}

Pro tip: I did not have to type check === true because the if statement automatically checks for true or false.

functions

var myFunction = function(){
  return 'hello';
}

variables also consume functions. These functions are called anonymous functions because they aren’t named.

arrays

var myArray = [1,3,4,5];

Arrays are a collection of data.

objects

var myObject = {me: "too", save: "me"};

Objects also hold a collection of data.

Other variables.

var newVariable = oldVariable;

Multiple variables!

var varOne = varTwo = varThree = 1;

Don’t try this one at home, because it has unwanted side effects. Variable assignment works from right to left. So in order for varOne to finally receive value, the other two variables are pushed to the global scope automatically. This means even functions won’t recognize varTwo and varThree as local variables. This is called leaking and is a pretty big no,no.

Closing Note

Variables are here to stay so make sure you get into the habit of using them. Whenever you find yourself using the same data type repeatedly, try sticking it into a variable. You’ll be happy you did.

Facebook opens Audience Network SDK beta program for developers, publishers

October 16, 2018 Posted by News 0 thoughts on “Facebook opens Audience Network SDK beta program for developers, publishers”

Facebook’s Audience Network platform allows brands and advertisers to push their Facebook ad campaigns beyond the social media platform. Having early access to an Audience Network SDK Beta program gives publishers and developers a head-start to using the new tool — it will offer them a chance to provide feedback on how the SDK can be improved before its launch.

“The input we receive from our developers and publishers is a valuable part in building and improving our solutions,” wrote Facebook on its Developer blog announcing the beta program. Facebook says input from users helps its team determine issues and create new features.

According to Facebook, Audience Network SDK beta users will have first-look access to the platform’s latest ad formats and tools, and will be able to use them immediately from the app. Among some of the features in the latest beta version, 5.0, are a reporting flow for Native Ads, multi-process support for Interstitial and Rewarded Video formats, a new Interstitial design for Mobile App Install ads.

Facebook has launched the beta program approximately one month prior to the official roll out.

More on the Audience Network SDK beta program

  • For publishers and developers interested in applying to the beta program, Facebook shared a link to its Business Manager site.
  • Those accepted into the beta program can earn Facebook advertising credits and connect with other beta testers in a closed developer community.
  • Facebook expects the official roll out for the SDK to happen around mid-November.

Top 5 Web development trends in 2018

October 9, 2018 Posted by News 0 thoughts on “Top 5 Web development trends in 2018”

New competitors pop up every day, so you have to keep your audience’s attention long enough to turn them into conversions. Web developers have also got a crucial role to play when it comes to catching and keeping the user’s attention, and they can do the same using some smart tactics.

In keeping with the times, here are the top 5 trends in web development that every developer should watch out for, and ensure the implementation of the same for better conversion rates. Exceed your customers’ expectations by dishing out something extra, and these 5 web development trends can tell you the ways to do it!

1. Revamped landing pages

Landing pages have gone through an unending process of transformation. Moving past the text-heavy landing page formats, we have come to light landing pages that focus more on the information being readily accessible to the user. Since Internet users do not care to read even a third of what you write as content, it is best to keep the text to a bare minimum when it comes to designing your landing pages. Use riveting web design templates and features (and tonnes of CTAs) on your landing page to cater to the streamlined queries and problems of your users.

2. Age of static site generators

Dynamic site content can readily be turned into static ones using static site generators. This is the go-to tool for most bloggers of the modern age. It ensures keeping a low budget and enhanced site loading speed, making your content accessible to users. Security factors can also be taken care of using static site generators, and you can convert plain text into creative websites using these site generators. Web developers who like to work on light software that runs on all servers can heavily benefit from this trend for sure.

3. Featuring hero images and videos

Go to your browser and open the homepages of Samsung or Nike. The first thing that greets you is a big and bold image of happy faces featuring their products. Since human brains process visuals way faster than text, why not take advantage of the same and create your website around it? Using hero images that feature in the homepage section of your website is thus a trend that is here to stay. The same goes for big and bold geometric patterns and fonts. If you want an even better effect, go for a slideshow format and stuff up that homepage with three or more hero images! The same goes for videos too. Videos help engage audiences faster and a few seconds of captivating content is enough to keep them hooked to your website for long. As a web developer, you should keep this trend in mind the next time you meet with your team to discuss alterations you can bring to your website.

4. Chatbots and interactive UI to the fore

Live chats and chatbots are ringing in a new age in conversational UI. They make our lives way simpler and take care of auto-reply functions with ease. Incorporating the same for your website can be one of the best ways for you to ensure engagement and a better user experience. Virtual assistants help users to shop and assist them to choose from products and cater to their problems or queries, which is the next big things in web development. It also helps users overcome the barrier of having to go through complicated processes of navigating through your site by including a simple chatbot-powered interactive feature to your website.

5. The rise of the JavaScript

2017 was the year of JavaScript with brilliant frameworks, technologies, and libraries. Riding on the JavaScript wave this year comes to the fundamentals that web developers need to get to the bottom of. Functions of JavaScript like the Builtin method, Closures, ES6, Pure Functions, Callbacks, RAIL, Promises, and Node have got the web developers around the world sitting up and taking notice. Since JavaScript also has the REACT library for building user interfaces, it can be the go-to solution for every web developer worth his coding skills this year as well. Combine frameworks like Meteor with resources from the library, and you will pave your way to a better website interface in the future.

Final Thoughts

Whether it is assisting users to shop online with just a live chat conversation with a chatbot or making websites way more engaging with loads of video content, keep the 5 brilliant web development trends in mind when developing your strategy for this year. Ensure smooth functioning of every feature in your website, catering to the mobile-only audience group, and make the all-around UX an enjoyable and efficient one. As a web developer of the modern age, that’s what you should be focusing on anyway. Since the industry keeps transforming itself with every new function added to a coding language or resource, brace yourself for the next major upheavals in web development.

Node.js Foundation and JS Foundation Announce Intent to Create Joint Organization to Support the Broad Node.js and JavaScript Communities

October 4, 2018 Posted by News, Programming 0 thoughts on “Node.js Foundation and JS Foundation Announce Intent to Create Joint Organization to Support the Broad Node.js and JavaScript Communities”

The Node.js Foundation and JS Foundation today announced an intent to merge. A Q&A session will be held onsite at Node+JS Interactive from 7:30am – 8:30am PT, October 10 at West Ballroom A. Anyone attending Node+JS Interactive is welcome to attend; questions can be submitted in advance anonymously via this Google Form.

Leaders from the Node.js Foundation Board of Directors, Technical Steering Committee and Community Committee will join representatives from the JS Foundation Board of Directors and Technical Advisory Committee to facilitate the discussion, answer questions and solicit community input on the possible structure of a new Foundation. Joining forces will not change the technical independence or autonomy for Node.js or any of the 28 JS Foundation projects such as Appium, ESLint, or jQuery.

JavaScript is a versatile programming language that has expanded far beyond its role as a backbone of the web, entering new environments such as IoT, native apps, DevOps, and protocols. As the ecosystem continues to evolve — moving from browsers to servers, desktop applications to embedded devices — increased collaboration in the JavaScript ecosystem is more important than ever to sustain continued and healthy growth.

“The Node.js Foundation and JS Foundation boards have met several times already to discuss a potential alignment of the communities. The Foundation leaders and key technical stakeholders believe that a tighter alignment of communities will expand the scope of the current Foundations and enable greater support for Node.js and a broader range of JavaScript projects,” said Mike Dolan, Vice President of Strategic Programs, the Linux Foundation.

“We are very interested in hearing directly from the community and welcome all questions, ideas and opinions so that the structure aligns with the expectations of the community. For this reason, no formal decisions regarding a merged Foundation and its potential organizational structure, governance policies, technical framework or leadership have been made at this point and will be formalized based on feedback from the community.”

Additional goals for a merger include:

  • Enhanced operational excellence;
  • Streamlined member engagement;
  • Increased collaboration across the JavaScript ecosystem and affiliated standards bodies;
  • An “umbrella” project structure that brings stronger collaboration across all JavaScript projects; and
  • A single, clear home available for any project in the JavaScript ecosystem.

Today, JavaScript is nearly ubiquitous. Enterprises have been able to greatly reduce training costs and increase developer productivity because frontend JS developers can work on the server side, and vice-versa, eliminating the context switches and enabling all developers to pull from the same knowledge base and vast module ecosystem. Node.js is a major catalyst for this growth. It has become an important part of the modern web development stack and is often the assumed default when working with JavaScript. Merging the Foundations will bring the governance of these technologies in line with its real-world use.

“JavaScript is at the core of an ecosystem of technologies that form the backbone of the web and play an increasingly vital role across industry and society,” said Dan Appelquist, Director of Web Advocacy & Open Source at Samsung Research UK and JSF Board Member. “Strong governance, encouraging inclusive contributor communities and engagement in the ongoing standards development are all important factors in ensuring this ecosystem continues healthy development. A merged foundation is well positioned to deliver on these goals.”

“The possibility of a combined Foundation and the synergistic enhancements this can bring to end users is exciting,” said Todd Moore, Node.js Board Chairperson and IBM VP Opentech. “Our ecosystem can only grow stronger and the Foundations ability to support the contributors to the many great projects involved improve as a result.”

About the Node.js Foundation
Node.js is used by tens of thousands of organizations in more than 200 countries and has around 10 million users. It is the runtime of choice for high-performance, low latency applications, powering everything from enterprise applications, robots, API engines, cloud stacks and mobile websites.

The Foundation’s membership base includes Platinum members Google, IBM, Intel, Joyent, and Microsoft. Gold members include GoDaddy, PayPal, and NodeSource, and Silver members include Bitnami, Chef, Dynatrace, Fidelity, Groupon, HackerOne, NearForm, npm, Oath:, Profound Logic, Red Hat, RisingStack, SafetyCulture, Sauce Labs, Snyk, and YLD. Get involved here: https://foundation.nodejs.org.

About the JS Foundation
The JS Foundation’s mission is to drive broad adoption and ongoing development of key JavaScript solutions and related technologies through ongoing efforts and services such as mentorship programs, events and support of web standards. The JS Foundation works to facilitate collaboration within the JavaScript development community to ensure its projects maintain the quality and diverse contribution bases that provide for long-term sustainability.

The Foundation is supported by members IBM and Samsung (Platinum); Accenture (Gold); and Agile FAQs, Blog Starter, BLOQspace, Bocoup, BrowserStack, Cloud Grey, Kenzan, Particle, Ripple, Sauce Labs, SitePen, Sourcegraph, StackPath, WebsiteSetup, and White October Events (Silver). Learn more about the members who support the Foundation and how to join at https://js.foundation/about/members.

Code JS in Stlye: Early Return

October 4, 2018 Posted by Programming 0 thoughts on “Code JS in Stlye: Early Return”

There comes a point in the life cycle of a project that we no longer have to worry about whether or not the darn piece of code works in the first place. We’ve got to look back and see if the darn piece of code has style.

In this series, we’ll explore how we can write code that’s worthy of the runway.

Today, we will be implementing the early return.

The IF Spaghetti

When we’re controlling the flow of data within a function, it can be tempting to use only a single return statement. A variable will be assigned a new value depending on a condition.

function divider(dividend, divisor){
   let response;
   if(isNaN(dividend) || isNaN(divisor))
   {
     response = "Error: input a number";
   }
   else if(divisor === 0)
   {
    response = "Error: cannot divide by 0";
   }
   else 
   {
    response = dividend / divisor;
   }
return response;
 }

Note: Admittedly, that else block is a stretch.

The code above has a single exit point(return statement), which is fine if you’re thinking in terms of functional logic. When we learn about functions for the first time, it’s ingrained in our being that you only return once. A function is a dog and a dog only has one tail, the return statement. Logically-speaking, the notion of multiple exit points can appear confusing…like a dog with multiple tails. “Which tail will the dog wag next?” is the sort of thing a cynic might say about functions that have multiple returns.

But a single exit point in a maze can create a game of cat and mouse as we peruse through nested conditions. If you looked at the earlier code example long enough, you may have gotten that nagging feeling that said, ‘if the condition is met, why are we not exiting right now? Why do we have to wait?’

It’s as if we reached a possible exit after meeting a condition, only to be funneled to a waiting room. Think: your flight’s delayed after meeting the condition of booking your ticket and being there on time. Yeah, rough.

Conversely, we can use early returns.

function divider(dividend, divisor){
   if(isNaN(dividend) || isNaN(divisor))
   {
     return "Error: input a number";
   }
   else if(divisor === 0)
   {
    return "Error: cannot divide by 0";
   }
return dividend / divisor;
 }

Multiple exit points allow us to make sense of the logic. Sometimes, we need to be reminded that we’re still within a function as we traverse conditions.

When you think about early returns in terms of pseudo code, you’ll realize that early returns are succinct.

If a condition is true 
  return value.

As opposed to,

If a condition is true
 assign a value
the value may or may not change...
return value

There’s less ambiguity, less confusion, and more assurance with early returns. It feels good to know that if you have a base case that handles invalid input, you are exiting the function immediately.

Doing otherwise is akin to dragging your feet, saying, “Yeah, yeah I’ll take care of that later.” Then, assigning the task of garbage disposal to someone else.

if(hackyInput)
{ 
  return; //!!!!
}
//vs
if(hackyInput)
{ 
  handleLater = ERROR_MSG; 
}

Sprinkling More Style

All of this code can be stripped down by deleting all of those brackets.

function divider(dividend, divisor){
   if(isNaN(dividend) || isNaN(divisor))
     return "Error: input a number";
   else if(divisor === 0)
    return "Error: cannot divide by 0";
return dividend / divisor;
 }
if(hackyInput) return; //!!!!
//vs
if(hackyInput) handleLater = ERROR_MSG;

Thoughts?

Of course, all of the above should be taken with a grain (or a couple more) of salt. At the end of the day, it is a style of programming. There is a time and place for early returns just like there’s a time and place for fanny packs(is there?).

It would be responsible to include a disclaimer. So here it is:

When you abuse the return statement by placing it in the middle of code, or, worse, a callback, you can create a hellish “Where’s Waldo?” debugging scenario. When your logic is bursting at the seams with complexity, so much so, that you need multiple returns to diffuse some of that complexity, then early returns become a crutch, rather than a tool. In that case, you may want to decouple your code, which is a nice way of telling you to nuke it.

Semantically, an early return should signify to the code reviewer that your first validation is make or break. The function cannot run without the condition being met. In that case, the early return reads more like a fail safe than clever coding.

At the end of the day, good style is in the eye of the beholder…for the most part.

Google’s new rules for developers make Chrome extensions safer

October 3, 2018 Posted by News 0 thoughts on “Google’s new rules for developers make Chrome extensions safer”

Google has announced a range of security changes to its Chrome browser that will make the use of extensions more secure. The updates, to be introduced in version 70 of the popular browser, cover areas including extension permissions and developer accounts.

Browser extensions are small programs that enhance its functionality. The problem is that misbehaving extensions can steal data or invade users’ browser privacy. Chrome is a trusted application in most operating systems, meaning that if you give an extension permission to do things, the operating system will usually wave it through. This can leave users vulnerable to malicious extensions.

In the past, Google has taken steps to keep extensions in line by limiting what they can do. Late last year, for example, it introduced an optional site isolation feature that made it more difficult for malicious code on one site to steal secrets from another when open in the browser. It also enabled administrators to block extensions based on the kinds of permissions they request, such as access to the webcam or the clipboard.

Per-site permissions

Now, it has announced plans to take things further. In Chrome 70, the company will enable users to restrict an extension’s permissions to manipulate website data and services on a per-site basis. When users gave a Chrome extension permission to read and change website data in the past, the extension could use those permissions across all sites. The change allows users to be more selective about the sites that the extension can access.

While you may want a screen clipping extension to read information from a handful of news sites that you visit, say, you might want it to avoid reading anything else, including your online bank account. Chrome 70 will restrict host access permissions to specific sites allowed by the user, or it can be configured to request approval for host access when visiting any site. The user can also enable host permissions on all sites by default if they wish.

Google will also make the review process more stringent for extensions that request ‘powerful permissions’, it said, and will also monitor extensions that use code hosted remotely.

Obfuscated code banned

The company is also banning the use of obfuscated code. This is JavaScript code that is scrambled to avoid others finding out what it does, and while this can be a way for developers to protect their IP, a good reverse engineer would eventually work out what it was doing, Google pointed out.

In the meantime, obfuscated code also enables cybercriminals, such as cryptojackers, to execute nefarious code under the hood. From now on, Google’s Chromium team is having none of it. Not only will all new extension submissions have to carry usable code, but existing extensions with obfuscated code will be removed from the Chrome Web Store in early January if they don’t fix the issue. The company said:

Today over 70% of malicious and policy violating extensions that we block from Chrome Web Store contain obfuscated code. At the same time, because obfuscation is mainly used to conceal code functionality, it adds a great deal of complexity to our review process. This is no longer acceptable given the aforementioned review process changes.

Minification, which reduces side code by removing comments and unused code and shortening variables, is still fine, it added.

2FA for extension developers

Google also changed the requirements for developers to access their online accounts. They will be expected to use two-step verification (or 2FA) to access their accounts in the Chrome Web Store from next year, the company stated. This is a bid to protect developers of popular extensions from having their accounts hijacked and their published extensions tampered with by malicious actors.

These enhancements may go some way towards mitigating malicious Chrome extensions, of which there have been a few.

One popular legitimate extension called Web Developer for Chrome was hijacked last year after criminals compromised the developer’s account.

Another extension named “Desbloquear Conteúdo” was evil from the start, inserting a perfect overlay of username, password, and one time pad form fields on a bank’s site.

Another extension named “Desbloquear Conteúdo” was evil from the start, inserting a perfect overlay of username, password, and one time pad form fields on a bank’s site.

The security changes are a precursor to version 3 of Google’s extensions manifest, which will make it harder to write insecure extensions, the company claimed. These changes will include more narrowly-scoped application programming interfaces (APIs) so that developers can give extensions more selective access to webpages. Expect those new changes next year.

Earn up to $121k per year as a C# developer

October 2, 2018 Posted by News 0 thoughts on “Earn up to $121k per year as a C# developer”

Are you ready to start your C# coding odyssey and earn big bucks as a software developer? You’ve picked the right day for it.

C# is a programming language often overlooked by first-time coders. There are some great reasons to give it a try, and not just because of the huge price drop on the Complete C# Coding Bootcamp right now.

C# (pronounced ‘C sharp’) is similar to C, but it’s generally considered to be easier to learn. That’s one reason why Microsoft developed it. Take C, update it to make it more powerful, simplify the code, and you’ve got C#.

C# developers earn $55k to $121k per year. (Source: Gooroo.io)

One of the main reasons to learn C# is the number of toolsets and frameworks that support the language, all of which are backed by Microsoft. For example, most developers agree that Visual Studio is one of the most feature rich and powerful development environments on the market.

C# gives you prospects too. It has mainstream adoption on the Microsoft and Unity platforms. Big software developers such as Blizzard Entertainment and Electronic Arts use it. Developers love the language for being easy to use and well-designed. Finally, Gooroo.io reports that, on average, C# developers earn $55k to $121k per year.

The Complete C# Coding Bootcamp is the ideal place to start learning. This mega bundle of 11 learning kits — produced by top experts in the industry — is over 89 hours of interactive tutorials and projects to get you C# coding in your sleep.

This online bootcamp also adds a host of transferable skills to add to your resume, such as HTML and CSS which are used in web development. You’ll come to terms with Microsoft Visual Studio, Eclipse, Unreal Engine, Unity, and various other programming environments.

The C# Bootcamp in full:

The 11 learning kits retail separately for a combined $765, but right now you can purchase the lot for just $41. You get lifetime access too, so it’s still worth picking up during the promotion even if you won’t have the time to start for a while.

Cobol Is Back In Demand

October 2, 2018 Posted by News 0 thoughts on “Cobol Is Back In Demand”

 

Like everything else, technology and computer coding languages come and go. A good example of this being an older programming language like C, originally developed in the late sixties, is still popular and widely used today.

And now, aside from C, another coding language dinosaur from the past is about to make a comeback. Read on and see why this programming language is not going away any time soon.

Eyes on the COBOL

Have you ever heard of the COBOL programming language? It stands for “Common Business-Oriented Language” and it was developed in 1959. You wouldn’t think technology nearly sixty years old would still be relevant, but it is.

If you want to get into the programming business, this just might be your ticket in. That’s because COBOL is still the most widely used programming language in financial institutions worldwide.

COBOL still powers millions of banking transactions every day. Plus, it’s not going away anytime soon since replacing banking systems that are already in place is a complicated and costly venture that most companies don’t even want to think about it.

With a whole generation of older COBOL programmers set to retire soon, there will be the inevitable demand for a new set of programmers who are proficient enough in the language to service this technology.

The problem? Younger programmers are not that much interested in learning such an old programming language. COBOL was unceremoniously declared dead 30 years ago and for modern coders, it is simply not glamorous enough anymore. They tend to focus more on newer languages that run apps, games and cloud computing.

This impending shortage makes COBOL programmers a highly sought-after commodity. You might want to look into it if you’ve been thinking about changing careers.

Fun fact: The current average annual salary for a COBOL programmer in the U.S. is $79,494.

How to level up your COBOL game

There are still various ways to learn COBOL but unfortunately, only a few universities still offer COBOL classes. Your best bet is to either read COBOL programming books and learn on your own or take online courses. Various tutorial sites like Lynda.com, AcademicTutorials, and TutorialsPoint have beginner COBOL lessons to get you started.

Some companies, like Accenture and Micro Focus International, recognize the relevance of COBOL even in this age of modern computing. Accenture still trains hundreds of Cobol programmers every year in India and the Philippines to address the shortage while Micro Focus International offers COBOL courses to around 400 colleges.

So, it looks like COBOL is here to stay (for the next decade or so, at least). If you’re looking into getting into COBOL, now is the perfect time.

Looking for a new career path? Check out our job openings here.

Hybrid Mobile App Development vs Native App Development

September 26, 2018 Posted by Apps, News 0 thoughts on “Hybrid Mobile App Development vs Native App Development”

What is native and hybrid app development?

-> Native app development means androids apps are built using the company’s software development kit and tools. In other words apps developed for a particular operating system with a native language. For instance, Java is used mostly for android apps and objective-C is used for IOS based apps.

-> In hybrid app development, the app is more flexible and is developed for multiple platforms. They are developed by HTML5, CSS, JavaScript and later on implanted in a native application using applications like NativeScript, Electron, Apache Cordova, Qt Creator to name some.

This write-up would focus on the perks and cons of hybrid and native app development thus proving an aid and abet to choose one of the best app development methods.

1.User Experience matters a lot:

As soon as you get a phone in your hand, you check for all the apps which you can install in your phone. But as per human tendency, if some app is not as per our expectation or is of no use further, you decide to uninstall the app and install another app. This cycle of installing and uninstalling apps continues.

Mobile app development companies are searching ways to get rid of this cycle of uninstalling and installing app. UI elements that are captivating, untroubled scrolling, gesture recognition which are rostrum friendly, quantum development in animation and effects, native apps lie where these features are highlighted.

In Native apps, the important factor was the apps are platform specific. But this is not the case with hybrid app development as they are built for multiple platforms. Since they have to satisfy the need of multiple platforms, they have to attune to UI specifics of multiple platforms concomitantly. Thus if UI is taking your whole attention, then definitely it’s native app development that you should choose.

Inference:

1)Hybrid apps are cost-effective unlike native apps. They are of high cost.

2)Native app is delivers high performance whereas hybrid delivers a moderate performance.

3)Native apps are complete platform specific UI but hybrid have common UI for all platforms.

2.Measure the Apps performance:

Being a regular user of smartphone, what irritates you the most? I know most of you would answer, “The time required to loading the page.

[Image Source: https://www.samirkamble.com/installing-and-setting-up-apache-cordova-phonegap-environment/]

From the above flowchart, hybrid apps can’t communicate directly with the device hardware. Whether it’s a mobile app or web app, the app first goes to the respective hybrid platform say Apache Cordova as shown. The code used may be in one of the three languages viz., HTML5, CSS, JavaScript. This platform executes the code and then address to device hardware. The content is loaded from the web server though this is not the case always, the performance depends on the speed of the internet. Talking about Native App, it communicates with the device hardware in a straight line. The unvarying content is downloaded as soon as the app is installed. Therefore the dependence of users on the speed of the internet is rock-bottom. Due to these reasons there is always a well-ordered and copper-bottomed work of the app.

Inference:

1) Native Apps have better performance as compared to hybrid apps.

2)There are page loading problems with hybrid apps unlike native apps.

3)There is direct communication with the device hardware in case of native apps unlike hybrid apps.

4)Sometimes hybrid apps are not responsive as compared to native apps.

3. Maintenance:

Hybrid apps are generally simple to maintain and easy to update the web technologies which is not the case with Native apps. Native apps require maintaining of codebases. Many users don’t upgrade their operating systems and continue to work on the older versions of operating system. Native app developers always have to therefore see that whatever the apps are upgraded to, should be compatible with both the versions i.e. the old as well as the new one.

Inference:

1.Hybrid Apps are easily maintainable.

2.Native app developers have to deal with device fragmentation which makes maintenance tedious.

4. Integration and Portability:

One of the most highlighted question of the era is “Where are you?” The important factor is people wants to know your location thus bringing location based apps on demand. For instance, on a social site, if you want to add the location and tell others about your check-in, then you will need GPS to be integrated with your app. This integration with native apps can be seamless because they are using built-in capabilities of the user device. Integration with hybrid apps are quite difficult. The reason is that apps have to adjusted as per the platform specific code and the integrate. This makes few devices harder to integrate.

Since native apps are specifically for a single platform, they are difficult to port. This becomes easier for hybrid apps due to its multiple platform nature. Hybrid apps are not platform specific thus, apps can be ported easily.

Inference:

1)GPS, camera, etc. can be integrated with native apps easily as compared to hybrid apps.

2)Hybrid apps can be easily ported as compared to native apps.

5.Time:

Businesses are adapting the methodology of lean development for quickest launch of their applications to compete with their rivals. Therefore people don’t find necessity to wait for longer period for app development. Taking this scenario in mind, it’s completely justifiable that why hybrid approach should be considered. Businesses which looks for a responsive and reliable product and ready to wait for more than 6 months are more prone to choose native approach.

Its often easier to create an app with hybrid approach due to its multiple platform feature unlike native. For native approach, the app has to be built in different platforms as per different devices dimensions.
Another point to remember, the changes made in hybrid are quicker to deliver to the end users without making them download the updates unlike native.

Inference:

1)Due to lean development methodology, it’s wise to use hybrid for less time consumption as compared to native.

2)Changes made on hybrid is easier ti deal and also updates are not needed to be downloaded by the end user.

6.Monetization:

For hybrid apps, its better to build a MVP so that you can test within limited market. If your app works out, then you can build a native version but if your app has failed or success rate is not as expected, then you have invested less in development time and cost. Moreover, in case of native apps, revenue generation is through app store and in-app subscriptions whereas, for hybrid, revenue is generated through in-app subscription and by hosting on multiple app stores.

Inference:

1)Revenue generation is through app store in case of native app.

2)Revenue generation is basically through in-app subscription by hosting on multiple apps.

Denouement:

This article was specifically written for people who wanted to get a clear view about native and hybrid apps and which is better to opt for. I have taken significant key of differentiation between the two and what was the inference from the paragraph under a specific key point.

Top 6 Issues Android App Developers Encounter

September 24, 2018 Posted by News 0 thoughts on “Top 6 Issues Android App Developers Encounter”

The primary target for businesses while working on mobile apps is the Android platform, thanks to the massive market share the mobile operating system holds. It’s popularity can be attributed to the fact that it is open source and is regular updated with new enhancements and features.

Android devices generally tend to differ based on the mobile hardware features even when powered by the same version of the Android OS. This is why it is essential that when developing apps for Android, developers create mobile apps capable of targeting a diverse range of mobile devices running on different versions of Android OS.

During the various stages of planning, developing and testing, developers need to focus comprehensively on the apps functionality, accessibility, usability, performance, and security so that users can be engaged despite their choice of device. Also, they also need to look for ways to make the apps deliver a more personalized user experience across the various devices an operating system. Furthermore, developers need to understand and find solutions to the common challenges involved in android app development.

Common Challenges Android App Developers Face

1. Hardware Features

The Android OS is unlike any other mobile operating system. For one thing, it is an open source system. Alphabet gives manufacturers the leeway to customize the operating system to their specific needs. Also, there are no regulations on the devices being released by the different manufacturers. As a result, you can find various Android devices with different hardware features running on the same Android version. Two smartphones running on Android latest ver, for example, may have different screen resolutions, camera, screen size, and other hardware structures. During android app development, developers need to account for all of this to ensure the application delivers a personalized experience to each user.

2. Lack of Uniform User Interface Design Rules

Since Google is yet to release any standard UI (user interface) design rules or process for mobile app developers, most developers don’t follow any standard UI development rules or procedure. Because developers are creating custom UI interfaces in their preferred way, a lot of apps tend to function or look different across different devices. This diversity and incompatibility of the UI usually affects the user experience that the Android app directly delivers. Smart developers prefer to go for a responsive layout that’ll keep the UI consistent across different devices. Moreover, developers need to test the UI of the app extensively by combining emulators and real mobile devices. Designing a UI that makes the app deliver the same user experience across varying Android devices is one of the more daunting challenges developers face.

3. API Incompatibility

A lot of developers make use of third-party APIs to enhance the functionality and interoperability of a mobile device. Unfortunately, not all third-party APIs available for Android app development are of high quality.. Some APIs were created for a particular Android version and will not work on devices running on a different version of the operating system. Developers usually have to come up with ways to make a single API work on all Android versions, a task they often find to be very challenging.

4. Security Flaws

As previously mentioned, Android is an open source software, and because of that, manufacturers find it easy to customize Android to their desired specifications. However, this openness and the massive market size makes Android a frequent target for security attacks. There have been several instances where the security of millions of Android mobile devices have been affected by security flaws and bugs like mRST, Stagefright, FakeID, ‘Certifi-gate,’ TowelRoot and Installer Hijacking. Developers need to include robust security features in their applications and utilize the latest encryption mechanisms to keep user information secure and out of the hands of hackers.

5. Search Engine Visibility

The latest data from Statista shows that Google Play Store contains a higher number of mobile apps. Additionally, a large number of Android users prefer free apps than paid apps which is why developers need to promote their mobile applications to increase their download numbers and employ application monetization options. The best way to promote the app to reach their target audience is to use comprehensive digital marketing strategies. Most developers make use of digital marketing professionals to promote their apps aggressively.

6. Patent Issues

Google doesn’t implement any guidelines for the evaluation of the quality of new apps that are getting submitted to the Play Store. This lack of a quality assessment guideline causes a lot of patent-related issues for developers. Some developers, to avoid patent issues, have to modify and redesign their apps in the future.

As per my personal experience, I have tried to cover general challenges faced by Android app developers. I’m sure keeping wary of these challenges would help developers to build successful apps in the most hassle free way. Source