Every major social media website uses some type of sharing button. Facebook has their like/share buttons, Pinterest has re-pin buttons, and Twitter has follow/retweet buttons.
A recent forum post on Twitter’s official community announced that Twitter will be released brand new redesigned buttons sometime around October/November. The release is expected to include a higher contrast between button background colors and text colors.
Each button widget is meant to serve visitors on external websites who want to share a piece of content on Twitter, or perhaps follow a specific account on Twitter without visiting the URL. It is possible to designers to create their own custom links, however Twitter’s widgets connect right into the API to pull realtime metrics.
There is no specific evidence to say that Twitter’s previous redesign has caused problems with contrast. But just by looking over the changes it should be obvious that grater contrast will have a lasting effect.
While the topic was published in Twitter’s forum area, the thread has been subsequently locked which prevents any further discussion.
So for the moment we’ll have to just wait & see how this progresses over the coming weeks. I’m sure the designers at Twitter will organize a proper blog post once the new button design nears an official release date.
The world-renowned prototyping tool InVision has consistently been on top of platform updates & new tools for designers. In a recent blog post they’ve announced a new feature called Motion.
This will behave as a built-in animation suite for InVision UI prototyping. Whether you’re designing for the web or mobile, animation is sure to be apart of many projects.
InVision Motion is a way for designers to create animated prototypes with similar tools that you might find in Adobe Flash. You’ll be able to control tweens, animation effects, keyframes, and build custom animations from scratch.
Motion has not been officially released but it’s currently in the works. There is no set release date but it has been officially announced as an upcoming feature for InVision users.
With Motion, you’ll be able to easily adjust the timing, duration, and easing of any animation—our animation engine will do the hard work for you. But if you want to get really technical, you could dive into the Motion code editor to take more control over how your animations present.
Definitely check out the blog post for more details + a small preview video of Motion applied to an InVision prototyping project.
If you’re a mobile developer with a focus on Apple devices then today is a big news day. It seems Apple has finally put out beta 2 versions of both iOS 9.1 and tvOS for development testing.
There have been some changes since the original beta releases but most of the foundational code remains. This means if you’re testing apps on the new platforms you should have no trouble continuing without an update.
Although most changes pertain to bug fixes, you can read through the tvOS beta2 notes publicly. The iOS 9.1 beta2 release notes are mixed into the overall 9.1 release, but again they are available online.
Interestingly Apple also released iOS 9.0.1 publicly on the same day. It seems Cupertino developers are hard at work pushing through changes for their latest line of mobile devices.
But wait, there’s more!
If you’re an Apple developer then you should know how to use Xcode. Apple just released the latest Xcode 7.1 beta 2 version for free online. Whether you have a dev account or not, you have access to this release and it’s completely free.
Keep in mind the beta versions of Xcode are for testing only. You cannot submit apps to the app store for publication with beta versions – so if you’re looking for a full professional workflow stick to the official Xcode 7 release until 7.1 is out of beta.
The following is a guest post by Faraz Kelhini. Some of this stuff is out of my comfort zone, so I asked Kyle Simpson to tech check it for me. Kyle’s answer (which we did during an Office Hours session) was very interesting. It was: 1) This article is technically sound. JavaScript doesn’t really have classes in a traditional sense and this is the way most people shoehorn them in. 2) We may want to stop shoehorning them in. JavaScript has objects and we can use them in the way they are intended to do the same kinds of things. Kyle calls it OLOO (Objects Linked to Other Objects). Here’s an intro. I’d think there is value in learning about both.
Having a good understanding of constructors is crucial to truly understand the JavaScript language. Unlike many other languages, JavaScript doesn’t support classes, but it has constructors to bring similar functionality to JavaScript. In this tutorial, we will explore constructors in detail and see how JavaScript utilizes them to make objects.
Constructors are like regular functions, but we use them with the “new” keyword. There are two types of constructors: native (aka built-in) constructors like Array and Object, which are available automatically in the execution environment at runtime; and custom constructors, which define properties and methods for your own type of object.
A constructor is useful when you want to create multiple similar objects with the same properties and methods. It’s a convention to capitalize the name of constructors to distinguish them from regular functions. Consider the following code:
function Book() {
// unfinished code
}
var myBook = new Book();
The last line of the code creates an instance of Book and assigns it to a variable; even though the Book constructor doesn’t do anything, myBook is still an instance of it. As you can see there is no difference between this function and regular functions except that we call it with the new keyword and the function name is capitalized.
Determining the Type of an Instance
To find out whether an object is an instance of another one, we use the instanceof operator:
myBook instanceof Book // true
myBook instanceof String // false
Note that if the right side of the instanceof operator isn’t a function, it will throw an error:
Another way to find the type of an instance is using the constructor property. All object instances have a constructor property that point to the constructor function that created it.
Consider the following code fragment:
myBook.constructor == Book; // true
Since the constructor property of myBook points to Book the result is true. All objects inherit a constructor property from their prototype:
var s = new String("text");
s.constructor === String; // true
"text".constructor === String; // true
var o = new Object();
o.constructor === Object; // true
var o = {};
o.constructor === Object; // true
var a = new Array();
a.constructor === Array; // true
[].constructor === Array; // true
Although checking constructor property can be used to check the type of an instance, it is recommended to only use the instanceof operator for this purpose, because the constructor property might be overwritten, so it cannot be a reliable method for checking the type of an instance.
Custom Constructor Functions
A constructor is like a cookie cutter to make more than one object with similar features. In other words, the benefit of using a constructor is that it makes it easy to create multiple objects with the same properties and methods.
Consider the following code:
function Book(name, year) {
this.name = name;
this.year = '(' + year + ')';
}
The book constructor expects two parameters: name and age; when it is called with the new keyword it assigns the received parameters to the name and year property of the current instance so the constructor can be used to create objects with initialized name and year properties:
var firstBook = new Book("Pro AngularJS", 2014);
var secondBook = new Book("Secrets Of The JavaScript Ninja", 2013);
var thirdBook = new Book("JavaScript Patterns", 2010);
console.log(firstBook.name, firstBook.year);
console.log(secondBook.name, secondBook.year);
console.log(thirdBook.name, thirdBook.year);
This code logs the following in the console:
As you can see, we can quickly build a large number of different book objects by invoking the Book constructor with different arguments. This is exactly the same pattern that JavaScript uses in its built-in constructors like Array() and Date().
Object.defineProperty Function
The Object.defineProperty() can be used inside of a constructor to help perform all necessary property setup. Consider the following constructor:
function Book(name) {
Object.defineProperty(this, "name", {
get: function() {
return "Book: " + name;
},
set: function(newName) {
name = newName;
},
configurable: false
});
}
var myBook = new Book("Single Page Web Applications");
console.log(myBook.name); // Book: Single Page Web Applications
// we cannot delete the name property because "configurable" is set to false
delete myBook.name;
console.log(myBook.name); // Book: Single Page Web Applications
// but we can change the value of the name property
myBook.name = "Testable JavaScript";
console.log(myBook.name); // Book: Testable JavaScript
In this code we used accessor properties inside the Object.defineProperty(). Accessor properties don’t include any properties or methods, but they define a getter to call when the property is read, and a setter to call when the property is written to.
A getter is expected to return a value, while a setter receives the value being assigned to the property as an argument. This constructor allows us to set or change the name property of instances, but we are not allowed to delete it, and when we get the value of name, the getter prepends the string “Book: ” to the name and returns it.
Object Literal Notations are Preferred to Constructors
The JavaScript language has nine built-in constructors: Object(), Array(), String(), Number(), Boolean(), Date(), Function(), Error() and RegExp(). When creating values we are free to use either object literals or constructors, but object literals are not only easier to read but also faster to run because they can be optimize at parse time. Whenever we need simple objects it’s best to stick with literals:
// a number object
// numbers have a toFixed() method
var obj = new Object(5);
obj.toFixed(2); // 5.00
// we can achieve the same result using literals
var num = 5;
num.toFixed(2); // 5.00
// a string object
// strings have a slice() method
var obj = new String("text");
obj.slice(0,2); // "te"
// same as above
var string = "text";
string.slice(0,2); // "te"
As you can see there’s hardly any difference between these object literals and constructors and we can still call methods on literals. It’s because when we call a method on a literal, behind the scene JavaScript converts the literal to a temporary object so that it’s possible to use object methods for primitive values, then JavaScript discards the temporary object.
Using the “new” Keyword is Essential
It’s important to remember to use the new keyword before all constructors, if we accidentally forget “new” we will be modifying the global object instead of the newly created object. Consider the following example:
function Book(name, year) {
console.log(this);
this.name = name;
this.year = year;
}
var myBook = Book("js book", 2014);
console.log(myBook instanceof Book);
console.log(window.name, window.year);
var myBook = new Book("js book", 2014);
console.log(myBook instanceof Book);
console.log(myBook.name, myBook.year);
When we call the Book constructor without new keyword, in fact we are just calling a function without a return statement and “this” inside the Book constructor will be equal to Window (instead of myBook), in other words we have unintentionally created two global variables which causes the code to produce unintended results, but when we call the function with the “new” keyword the context is switched from global (window) to the instance, therefore “this” points to myBook. Here is what the above code logs in browser console:
Note that in strict mode this code throws an error because strict mode protects us from accidentally calling a constructor without the new keyword.
Scope-Safe Constructors
Since a constructor is just a function, it can be called without the new keyword, but this leads to unexpected results and errors especially for inexperienced programmers. The solution to this problem is scope-safe constructors. We can call Scope-safe constructors with or without new keyword and they return the same result in either form.
Most of built-in constructors, such as Object, Regex and Array, are scope-safe. They use a pattern to determine whether the constructor is called with new or not.
If new isn’t used, a proper instance of the object is created by calling the constructor again with new keyword. Consider the following code:
function Book(name) {
if (!(this instanceof Book)) {
// the constructor was called without "new".
return new Book(name);
}
}
So using this pattern we can easily rewrite a scope-safe version of our constructor:
function Book(name, year) {
if (!(this instanceof Book)) {
return new Book(name, year);
}
this.name = name;
this.year = year;
}
var person1 = new Book("js book", 2014);
var person2 = Book("js book", 2014);
console.log(person1 instanceof Book); // true
console.log(person2 instanceof Book); // true
The fact that “this” is an instance of the custom type allows us to determine if new is not used as soon as the constructor begins to execute and run the constructor again with new keyword.
Conclusion
JavaScript has no class statement, which is baffling for coders who are used to languages with a class statement; However, JavaScript has constructors to bring similar functionality. Constructors are just regular functions which are used with new keyword. They come in handy when we need to make multiple similar objects with the same properties and methods.
There’s a lot to be said about the success of Django. It’s gained plenty of traction on the web as a serious framework for developing all types of applications at lightning speed.
Many different content management systems exist including the titular Django CMS. But an interesting contender in this field is Wagtail CMS, another open source alternative for Python/Django developers.
Wagtail is open source running the BSD license. All code is editable and you can even work with others to append changes via the GitHub repo.
Like every developer looking into new technology, you’re probably curious about features. Wagtail CMS has a full features page covering some of the more poignant options available. Right out of the box it comes with a dynamic search engine & form builder, along with a tree-based content hierarchy for an easy time managing edits.
The idea of Wagtail is for editing to be simple. Developers know how to read code, but a CMS is often geared towards non-technical people who want to manage their own website. Thankfully content editing has really been overhauled to give this CMS a more natural feel of inline editing.
Any Django developers who might want to give this a spin should download a copy and read up on the Wagtail documentation. It’s a completely free CMS engine built with content management in mind. Django developers are always looking for a clean platform to use for new websites, and Wagtail offers the perfect opportunity to test the waters in a new area.
Also if you want to see it in action check out their official demo video:
There seem to be endless choices regarding how to accomplish the same task – to develop a website that works in today’s modern web. Web developers have to choose a web hosting platform and underlying data storage, which tools to write HTML, CSS, and JavaScript in, how design will be implemented, and what potential JavaScript libraries/frameworks to include. Once choices are narrowed down, the online world is filled with articles, forums, and samples that provide tips for making a better web experience. Yet no matter which path is taken, all developers are susceptible to mistakes. Although some mistakes will be related to a specific approach, there are challenges shared among all web developers. So through research, experience, and recent observations, I thought I would share a list I compiled of ten common mistakes I see web developers make – and how to avoid them. The following list is in no particular order. 1) Writing Old School HTML Mistake: The early days of the internet had much fewer options for markup than we do today. However, old habits die hard, and many still write their HTML as if we were still in the 20th century. Examples here are using
elements for layout , or
elements […]
* You might also be interested in the following articles
The command-line interface has always been popular in the world of developers, because it provides tools that boost productivity and speed up the development process. At first sight, it might seem hard to believe that using the command line to perform certain tasks is getting easier than using a graphical interface. The purpose of this article is to clear up your doubts about that, at least concerning WordPress tasks.
WordPress provides a graphical user interface for every administrative task, and this has helped to make it the most popular content management system on the web. But in terms of productivity, working with the command line enables you to accomplish many such tasks more efficiently and quickly.
The beauty of open source is built within the community, along with all the many derivative works to follow. Designers and developers can benefit from working with each other’s graphics and source codes to learn and produce higher-quality results. It offers a practical method to build websites and other projects that would need a solid user interface. Icons are typically one big piece to this overall design process.
Below you will find 34 free icon sets released during 2013. This includes some vectors, glyphs, larger glossy icons and even tiny sprites. There is something in here for every project and they’re all free to download. If I’ve missed any other new icon sets please share with us in the comments area below.
Out of the litany of mobile app development conferences, Mobiconf seems to draw a lot of attention from all forms of developers. In 2015 Mobiconf will be held in Krakow, Poland from October 1st-2nd.
This two-day event covers a range of 30 different events with over 25 unique speakers. How is this even possible?
By segmenting the event into three distinct tracks that cover individual interests like web, iOS, & Android. You can view the full schedule from their website with a list of talks.
Many of the speakers at this event come from native Polish companies, both agencies and larger mobile applications. But you’ll also find speakers like Michael England who’s a core enginner at SoundCloud, or Vitaly Friedman as the editor-in-chief of Smashing Magazine.
Overall this is sure to be a fantastic conference for anyone interested to learn more about the world of mobile interfaces. Speakers will cover everything from responsive design to mobile web browsers, along with app development techniques for the major 3 OS'(iOS/Android/Windows Mobile).
Conference registration is still open if you’d want to order your ticket for early October.
Additionally if you can’t make it to the conference be sure to follow along with updates on Facebook, or watch out for their latest tweets @mobiconf.
With millions of mobile applications on the market, competition is more vigorous than ever. And as new applications continue to release the number of applications is only going to escalate.
But an interesting trend of mobile application success is that it’s quite brutal. While there are successful applications like Angry Bird or Temple Run, there are a colossal number of applications that have failed to get off the ground.
It’s not wrong to say that developing a successful mobile application is challenging. It certainly requires one to juggle various factors that I’ll cover in this post.
What represents the success of an application?
An application’s success is often confused with the number of downloads it drives. However research has shown that many downloaded applications are abandoned after only the first use.
So what else represents a successful application?
There are a number of things that contribute to an application’s success. If you are only focusing to generate the number of app installs, you are likely to lose your mobile app business.
While it’s essential to get as many users as possible, it is also vitally important to get the application into the hands of those who can achieve your goals by taking appropriate actions and using the app on a regular basis.
Whether you’re an application designer or developer, you can augment the success of your application with a few steps. All you need to do is consider a few crucial factors that can influence the surefire success of your product.
I’d like to share some key points that can help you attain your intended goals with flair.
Make your app colors create a hierarchy
By implementing suitable colors you can beautifully express the purpose of UI elements. For instance, you may choose to use any color to share the importance of a particular button. Even shades of gray can create a hierarchy and reflect which element is crucial for potential users. Also you can make CTA buttons more attractive and appealing by using an eye-catching color that stands out from the rest of the application.
Start with a Prototype
Beginning with an app prototype can help you plan ahead & proceed in the right direction. With an app prototype you can scrutinize loopholes before investing your invaluable time and efforts toward development.
Once a prototype is developed you can iterate it by considering the users’ expectations and the business objectives until you get a satisfactory result. This will eventually help deliver a prolific solution.
Maintain Visual Consistency
While designing the UI for your application make sure that you are not breaking visual consistency. There’s no doubt that a consistent UI and UX design can deliver an overhauled performance.
Thus it’s advisable to maintain the design consistency throughout the application. Whether it’s about the placement of UI elements or their appearance, you must keep them all in harmony from one page to another, so that users can seamlessly and flawlessly interact with the design and take a suitable action.
Don’t Lose Focus
Whether you’ve chosen iOS or Android for your mobile platform, you can entice your potential audience and help them navigate through your app with ease. Stay focused and don’t lose sight of the users that you’re targeting.
Endeavor for Highest-Level Security
While the advancement in technology offers notable benefits (online shopping, e-payments and a lot more), it also increases the probability of risk. Mobile application security is one of the most crucial points to mobile users.
Users are more conscious about app security than ever before. You must embed security measures in your app development cycle. Recognize the most essential points and streamline tests for capturing bugs, fixing them, and how data should be stored/encrypted.
Consider What Potential Users Admire
As an app developer you can increase the likelihood of your application’s success by considering the users’ feedback on the competitive applications that are already available in the market. Especially when you’re creating an application for a startup company that doesn’t embrace any digital presence.
Heighten the Brand Value
You should integrate brand colors to connect users with the brand and heighten recognition of the business.
As such, it is advisable to choose your brand colors wisely. Make it certain that they are visually pleasing and somehow epitomizing the vision of the business.
In a Nutshell
In this mobile age no one can afford to ignore the expectations of mobile users or the power of a stupendous mobile presence. Learning the strategies that can help deliver an impressive, interactive and innovative mobile solution can ensure its market success. You might be designing and developing a mobile application for a startup or a well-established firm.
No matter if you are a novice, intermediate, or expert professional, bearing these tips in mind can help you deliver a very successful mobile application.
