by via Awwwards - Sites of the day
Thursday, August 31, 2017
Bear Grylls
by via Awwwards - Sites of the day
The State of Social Sharing in 2017 [infographic]
Social Marketing is becoming more and more complex.Every year new challengers try to grab some of Facebook’s market share. In some cases, it can be a great opportunity for businesses that want to get an edge over the competition. At GetSocial, we’re tracking 30+ social networks and messaging apps,...
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Web Desk via Digital Information World
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Web Desk via Digital Information World
Learning JavaScript: 9 Common Mistakes That Are Holding You Back
A lot of people try to learn JavaScript and then give up. Then they tell themselves things like, "JavaScript is too confusing," or worse, "Maybe I'm not cut out for web development."
The sad part? There was no need to give up. All that was needed was a different learning approach.
In this article, we'll cover some of the most common learning mistakes people make and find out how to avoid them. Many of these tips will be applicable outside of JavaScript or even web development, so there's that bonus too.
Let's dive in!
Mistake #1: Overanalyzing Instead of Getting Started
It can be tempting to look for all the information you can get before you start learning JavaScript. If you look, you'll find information about how JavaScript is the best thing ever or the worst thing ever, or that you need to be on this framework or that framework. You might also hear that you need to write JavaScript a certain way or else you'll never be a "real" developer.
Whether or not these points have validity, nothing is worse than the six months to a year you'll waste agonizing instead of starting.
Just type one line of code. It doesn't have to be perfect. It can be terrible. If you get started, you've already passed one of the hurdles that stop a lot of people.
Mistake #2: Learning a Framework Before Learning Plain JavaScript
JavaScript frameworks are built on top of vanilla JavaScript, so if you understand JavaScript, you automatically understand the fundamentals of how to use any JavaScript framework.
However, if you jump straight into a framework, you'll end up memorizing without understanding. It's like trying to write sentences without knowing what words mean. You'll end up memorizing random phrases instead of understanding how words work and how to put them together to make your own sentences.
If you go straight to a framework it'll be harder to learn and you'll have a harder time adapting to another framework if you need to. If you learn plain JavaScript first, you have a firm basis to understand all the frameworks.
Mistake #3: Moving to the Next Step Too Soon
One of the most common mistakes is to move on immediately after understanding a concept.
I've definitely struggled with this one because it's tempting to move forwards once you understand something.
What helped was to treat each concept like a new toy; That means taking some time to enjoy what you just learned. Play around, experiment, see if you can do something new with it. You'll learn a lot that way, and you'll remember better as well.
Once you feel like you can apply a concept in your sleep, move on. It takes a little bit more time up front, but soon it makes everything go much faster.
On the other hand, if you rush, you'll end up forgetting and having to backtrack for every little thing. That ends up taking way more time, and it can be discouraging. In fact, this is a common reason people have said they quit JavaScript.
Mistake #4: Not Breaking Concepts Into Small Enough Pieces
Learning is like a staircase: If you can take one step, you can keep taking more steps until you reach your goals. When something is tough to understand, it's often because you're trying to take a flying leap instead of going one step at a time. Of course, it seems impossible!
Continue reading %Learning JavaScript: 9 Common Mistakes That Are Holding You Back%
by Yaphi Berhanu via SitePoint
5 Social Sharing Tools for Teams
Do you want your employees to contribute to your social media marketing? Looking for tools to manage the content people share on social? In this article, you’ll discover five tools that will help you coordinate the content your team posts on social media. #1: Leverage Employee Advocacy With Smarp If you’re looking for ways to [...]
This post 5 Social Sharing Tools for Teams first appeared on .
- Your Guide to the Social Media Jungle
by Cynthia Johnson via
Wednesday, August 30, 2017
How to Create CSS Conic Gradients for Pie Charts and More
More and more websites use gradients in one way or another. Some websites use them for navigation components, while others use them in elements like buttons, or with images to create some nice effects.
All browsers have had support for basic CSS linear and radial gradients for a long time now. The CSS Gradients: A Syntax Crash Course article on SitePoint gives you a quick summary of the syntax required to create linear and radial gradients, as well as how to use repeating gradients to create some basic patterns, which is great if you care about web performance and try to avoid using images whenever possible.
After linear and radial gradients, browsers are now slowly starting to support conic gradients, which were first championed by Lea Verou.
In this article, you will learn about the syntax, uses, and browser support for simple conic gradients and repeating conic gradients.
What are Conic Gradients?
Conic and radial gradients are similar in the sense that both of them start from a specified or default point as the center of the circle used to draw them. The difference between the two is that, in the case of radial gradients the color-stops are placed along the radial line, while in the case of conic gradients the color stops are placed along the circumference of the circle.
The position of color-stops for a conic gradient can be specified either in terms of percentage or in terms of degrees. A value of 0% or 0deg refers to the top of the conic gradient. The values keep increasing gradually as you move clockwise. A value of 360deg is equivalent to 0deg. Any color whose color-stop value is greater than 100% or 360deg won't be drawn on the conic gradient but it will still affect its color distribution.
The following image shows a conic gradient that starts with a yellow color and ends with orange.
It is hard not to notice the sharp transition that separates the orange at 360deg from the yellow at 0deg. Remember that conic gradients always produce this transition whenever the starting and ending colors of the conic gradient are very different. One way to avoid it is setting the starting and ending color to the same value.
Syntax for Conic Gradients
Continue reading %How to Create CSS Conic Gradients for Pie Charts and More%
by Gajendar Singh via SitePoint
6 jQuery Form Wizard Plugins
A jQuery Form Wizard is a jQuery plugin that assists with the creation of forms with some sort of form flow (without refreshing your page). For example, if you had a large form for entering user data, you could use a form wizard to divide it into a series of related steps. This has the advantage of not overwhelming users with a really long form and also giving them some indication of their progress as they enter their information.
In this post we list 6 of our favorite jQuery form wizards, examine their different features and finally look at a couple of paid options, as well as how to create your own. This isn't intended to be an exhaustive list, but if you are looking for a jQuery form wizard, then hopefully this will point you in the right direction.
This popular post was updated on 30.08.2017. Broken / abandoned plugins were removed from the list and new plugins were added to reflect features people were asking for in the comments.
1. jQuery Steps
jQuery Steps is a smart UI component which allows you to easily create wizard-like interfaces. This plugin groups content into sections for a more structured and orderly page view. It has a plethora of features, such as async content loading, state persistence (it saves your input between steps) and transition effects between sections. It can be installed via NuGet or bower and has a well-documented and feature-rich API.
2. jQuery Smart Wizard
Smart Wizard is a flexible and heavily customizable jQuery step wizard plugin with Bootstrap support. It is easy to implement and gives a neat and stylish interface for your forms, checkout screen, registration steps etc. Its features include theme support (with various themes included), URL navigation and step selection and the ability to dynamically hide or disable steps. It can be installed via npm, bower or composer and has a well-documented and feature-rich API.
3. formToWizard
This lightweight plugin turns any webform into multi-step wizard with jQuery, whereby every form <fieldset> is turned into a separate step with forward and back buttons. It doesn't have nearly as many features as the previous two plugins, but does integrate with the jQuery validation plugin to provide validation functionality. It is a single file (so you can just grab it off GitHub and go) and if JavaScript is unavailable, it degrades gracefully.
Continue reading %6 jQuery Form Wizard Plugins%
by James Hibbard via SitePoint
#305: A Thorough Guide to Building Layouts with CSS Grid
|
by via Frontend Focus
Debunking 3 Common WordPress Myths
As the largest and most widely used content management system (CMS) on the internet, it should come as no surprise that people are constantly trying to bring WordPress down. Naturally, a number of WordPress myths have been conjured up over the years. In order to be properly informed, you have to make sure you know how to separate fact from fiction.
WordPress: The Leading CMS Platform on the Web
WordPress isn’t the only CMS around, but it certainly blows the competition out of the water in terms of adoption and appeal. Just consider the popularity of the platform:
- As of last count, WordPress powers more than 26 percent of the web and has a whopping 59.4 percent market share, which makes it the most used CMS platform.
- More than 500 sites a day are created on the WordPress platform.
- There are 44,225 WordPress plugins, which have been downloaded more than 1.25 billion times.
- WordPress is translated into 56 different languages worldwide.
These are just a few of the striking data points. When you dig into the nitty gritty of WordPress, it becomes clear that this is one of the most superior CMS platforms on the web. But along with this title comes a target. When you’re the best, people want to tear you down. And when they can’t tear you down, they resort to bending the truth or making things up altogether.
Don’t Fall for These 3 WordPress Myths
In order to be an informed website developer, entrepreneur, or business owner, you need to be cognizant of the fact that the internet is filled with myths regarding WordPress.
Here are three of the most common myths about WordPress:
Myth #1: WordPress Isn’t Scalable
Somewhere along the line, a myth has been perpetuated that WordPress isn’t scalable. Some people believe that it’s a platform that’s only suited for small blogs and tiny business websites. However, this simply isn’t true. If you look at the facts, you’ll see that WordPress is anything but a CMS designed exclusively for small sites. Just ask celebrities and businesses who regularly rely on WordPress for their websites.
Musicians like Beyonce, Justin Bieber, Snoop Dogg, Katy Perry, and The Rolling Stones all use WordPress. From the business side of things, companies like Bacardi, Sony Music, Mercedes Benz, The Rotary Club, and the New Yorker Magazine are all WordPress users.
One of the primary reasons why large businesses and brands use WordPress is that it is scalable. Not only are the search, caching, and content delivery capabilities top-notch, but there’s also true horizontal scalability. This allows websites with high traffic demands to always have sufficient architecture on-demand if they need it.
Put simply, the idea that WordPress isn’t scalable is ridiculous. "With the right infrastructure, services and resources, WordPress is highly scalable," Pragmatic explains. "It can serve tens of thousands of logged in users at a time and deliver hundreds of millions of monthly page views. It can process page requests immediately and can produce lightning-quick results to search queries. It is flexible, upgradeable and ultimately can power all manner of websites, right up to the largest and most visited."
Continue reading %Debunking 3 Common WordPress Myths%
by Larry Alton via SitePoint
40 Social Media Video Marketing Stats for 2017
Social media video marketing continues to be an uptrend in any and all industry commerce. In the last 30 days, more online video content has been uploaded to the web than in the past 30 years of TV content. Marketers who have been used to the forced audience captivation of commercials now need to...
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Irfan Ahmad via Digital Information World
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Irfan Ahmad via Digital Information World
6 Best New Android Launchers 2017! [video]
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Web Desk via Digital Information World
UX Lessons from Amazon: 4 Hacks Guaranteed to Boost Conversions
I’ll admit, Amazon’s visual design is awful and kind of outdated. I’m sure a lot of UX experts will agree with me on that, so naturally, an article sharing UX lessons from Amazon might raise some eyebrows at first.
However, while Amazon still has a lot of work to do on their visual design (it’s 2017 after all, users care about aesthetics!), we can still learn a lot from Amazon in regards to user experience. In fact, Amazon has an amazingly-effective UX system, where research shows that they were responsible for 53% of ALL online retail sales growth in the U.S. in 2016 alone. Yes, read that again.
One single company was responsible for 53% of retail sales growth in a country as big and diverse as the U.S.
How did Amazon do it? Let's take a look.
1. Having a Well-Oiled "Recommendations Engine"
If there's something Amazon has mastered, it's the subtle art of reading their users’ mind (or, rather, putting things into their users’ mind?). If you shop on Amazon, as soon as you order something, before you even realize that you need something to complement it, complementary options are staring you right in the face.
Continue reading %UX Lessons from Amazon: 4 Hacks Guaranteed to Boost Conversions%
by John Stevens via SitePoint
The Hottest Visual Content Marketing Trends for 2017 [infographic]
Visual content, done well, can be incredibly popular. Infographics, videos, data visualizations, and other forms of visual content can generate tons of engagement and attract links to your site. More importantly, visuals help tell your story. Visual content can be an incredibly powerful marketing...
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Web Desk via Digital Information World
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Web Desk via Digital Information World
Polymorphism With Protocols in Elixir
Polymorphism is an important concept in programming, and novice programmers usually learn about it during the first months of studying. Polymorphism basically means that you can apply a similar operation to entities of different types. For instance, the count/1 function can be applied both to a range and to a list:
Enum.count(1..3) Enum.count([1,2,3])
How is that possible? In Elixir, polymorphism is achieved by using an interesting feature called a protocol, which acts like a contract. For each data type you wish to support, this protocol must be implemented.
All in all, this approach is not revolutionary, as it is found in other languages (like Ruby, for example). Still, protocols are really convenient, so in this article we will discuss how to define, implement and work with them while exploring some examples. Let's get started!
Brief Introduction to Protocols
So, as already mentioned above, a protocol has some generic code and relies on the specific data type to implement the logic. This is reasonable, because different data types may require different implementations. A data type can then dispatch on a protocol without worrying about its internals.
Elixir has a bunch of built-in protocols, including Enumerable, Collectable, Inspect, List.Chars, and String.Chars. Some of them will be discussed later in this article. You may implement any of these protocols in your custom module and get a bunch of functions for free. For instance, having implemented Enumerable, you'll get access to all the functions defined in the Enum module, which is quite cool.
If you have come from the wondrous Ruby world full of objects, classes, fairies and dragons, you'll have met a very similar concept of mixins. For example, if you ever need to make your objects comparable, simply mix a module with the corresponding name into the class. Then just implement a spaceship <=> method and all instances of the class will get all methods like > and < for free. This mechanism is somewhat similar to protocols in Elixir. Even if you have never met this concept before, believe me, it is not that complex.
Okay, so first things first: the protocol must be defined, so let's see how it can be done in the next section.
Defining a Protocol
Defining a protocol does not involve any black magic—in fact, it is very similar to defining modules. Use defprotocol/2 to do it:
defprotocol MyProtocol do end
Inside the protocol's definition you place functions, just like with modules. The only difference is that these functions have no body. It means that the protocol only defines an interface, a blueprint that should be implemented by all the data types that wish to dispatch on this protocol:
defprotocol MyProtocol do def my_func(arg) end
In this example, a programmer needs to implement the my_func/1 function to successfully utilize MyProtocol.
If the protocol is not implemented, an error will be raised. Let's return to the example with the count/1 function defined inside the Enum module. Running the following code will end up with an error:
Enum.count 1 # ** (Protocol.UndefinedError) protocol Enumerable not implemented for 1 # (elixir) lib/enum.ex:1: Enumerable.impl_for!/1 # (elixir) lib/enum.ex:146: Enumerable.count/1 # (elixir) lib/enum.ex:467: Enum.count/1
It means that the Integer does not implement the Enumerable protocol (what a surprise) and, therefore, we cannot count integers. But the protocol actually can be implemented, and this is easy to achieve.
Implementing a Protocol
Protocols are implemented using the defimpl/3 macro. You specify which protocol to implement and for which type:
defimpl MyProtocol, for: Integer
def my_func(arg) do
IO.puts(arg)
end
end
Now you can make your integers countable by partly implementing the Enumerable protocol:
defimpl Enumerable, for: Integer do
def count(_arg) do
{:ok, 1} # integers always contain one element
end
end
Enum.count(100) |> IO.puts # => 1
We will discuss the Enumerable protocol in more detail later in the article and implement its other function as well.
As for the type (passed to the for), you may specify any built-in type, your own alias or a list of aliases:
defimpl MyProtocol, for: [Integer, List] do end
On top of that, you may say Any:
defimpl MyProtocol, for: Any
def my_func(_) do
IO.puts "Not implemented!"
end
end
This will act like a fallback implementation, and an error will not be raised if the protocol is not implemented for some type. In order for this to work, set the @fallback_to_any attribute to true inside your protocol (otherwise the error will still be raised):
defprotocol MyProtocol do @fallback_to_any true def my_func(arg) end
You can now utilize the protocol for any supported type:
MyProtocol.my_func(5) # simply prints out 5
MyProtocol.my_func("test") # prints "Not implemented!"
A Note About Structs
The implementation for a protocol can be nested inside a module. If this module defines a struct, you don't even need to specify for when calling defimpl:
defmodule Product do
defstruct title: "", price: 0
defimpl MyProtocol do
def my_func(%Product{title: title, price: price}) do
IO.puts "Title #{title}, price #{price}"
end
end
end
In this example, we define a new struct called Product and implement our demo protocol. Inside, simply pattern-match the title and price and then output a string.
Remember, however, that an implementation does have to be nested inside a module—it means that you can easily extend any module without accessing its source code.
Example: String.Chars Protocol
Okay, enough with abstract theory: let's have a look at some examples. I am sure you have employed the IO.puts/2 function quite extensively to output debugging info to the console when playing around with Elixir. Surely, we can output various built-in types easily:
IO.puts 5 IO.puts "test" IO.puts :my_atom
But what happens if we try to output our Product struct created in the previous section? I will place the corresponding code inside the Main module because otherwise you'll get an error saying that the struct is not defined or accessed in the same scope:
defmodule Product do
defstruct title: "", price: 0
end
defmodule Main do
def run do
%Product{title: "Test", price: 5} |> IO.puts
end
end
Main.run
Having run this code, you'll get an error:
(Protocol.UndefinedError) protocol String.Chars not implemented for %Product{price: 5, title: "Test"}
Aha! It means that the puts function relies on the built-in String.Chars protocol. As long as it is not implemented for our Product, the error is being raised.
String.Chars is responsible for converting various structures to binaries, and the only function that you need to implement is to_string/1, as stated by the documentation. Why don't we implement it now?
defmodule Product do
defstruct title: "", price: 0
defimpl String.Chars do
def to_string(%Product{title: title, price: price}) do
"#{title}, $#{price}"
end
end
end
Having this code in place, the program will output the following string:
Test, $5
Which means that everything is working just fine!
Example: Inspect Protocol
Another very common function is IO.inspect/2 to get information about a construct. There is also an inspect/2 function defined inside the Kernel module—it performs inspection according to the Inspect built-in protocol.
Our Product struct can be inspected right away, and you'll get some brief information about it:
%Product{title: "Test", price: 5} |> IO.inspect
# or: %Product{title: "Test", price: 5} |> inspect |> IO.puts
It will return %Product{price: 5, title: "Test"}. But, once again, we can easily implement the Inspect protocol that requires only the inspect/2 function to be coded:
defmodule Product do
defstruct title: "", price: 0
defimpl Inspect do
def inspect(%Product{title: title, price: price}, _) do
"That's a Product struct. It has a title of #{title} and a price of #{price}. Yay!"
end
end
end
The second argument passed to this function is the list of options, but we are not interested in them.
Example: Enumerable Protocol
Now let's see a slightly more complex example while talking about the Enumerable protocol. This protocol is employed by the Enum module, which presents us with such convenient functions as each/2 and count/1 (without it, you would have to stick with plain old recursion).
Enumerable defines three functions that you have to flesh out in order to implement the protocol:
- count/1 returns the enumerable's size.
- member?/2 checks whether the enumerable contains an element.
- reduce/3 applies a function to each element of the enumerable.
Having all those functions in place, you'll get access to all the goodies provided by the Enum module, which is a really good deal.
As an example, let's create a new struct called Zoo. It will have a title and a list of animals:
defmodule Zoo do defstruct title: "", animals: [] end
Each animal will also be represented by a struct:
defmodule Animal do defstruct species: "", name: "", age: 0 end
Now let's instantiate a new zoo:
defmodule Main do
def run do
my_zoo = %Zoo{
title: "Demo Zoo",
animals: [
%Animal{species: "tiger", name: "Tigga", age: 5},
%Animal{species: "horse", name: "Amazing", age: 3},
%Animal{species: "deer", name: "Bambi", age: 2}
]
}
end
end
Main.run
So we have a "Demo Zoo" with three animals: a tiger, a horse, and a deer. What I'd like to do now is add support for the count/1 function, which will be used like this:
Enum.count(my_zoo) |> IO.inspect
Let's implement this functionality now!
Implementing the Count Function
What do we mean when saying "count my zoo"? It sounds a bit strange, but probably it means counting all the animals that live there, so the implementation of the underlying function will be quite simple:
defmodule Zoo do
defstruct title: "", animals: []
defimpl Enumerable do
def count(%Zoo{animals: animals}) do
{:ok, Enum.count(animals)}
end
end
end
All we do here is rely on the count/1 function while passing a list of animals to it (because this function supports lists out of the box). A very important thing to mention is that the count/1 function must return its result in the form of a tuple {:ok, result} as dictated by the docs. If you return only a number, an error ** (CaseClauseError) no case clause matching will be raised.
That's pretty much it. You can now say Enum.count(my_zoo) inside the Main.run, and it should return 3 as a result. Good job!
Implementing Member? Function
The next function the protocol defines is the member?/2. It should return a tuple {:ok, boolean} as a result that says whether an enumerable (passed as the first argument) contains an element (the second argument).
I want this new function to say whether a particular animal lives in the zoo or not. Therefore, the implementation is pretty simple as well:
defmodule Zoo do
defstruct title: "", animals: []
defimpl Enumerable do
# ...
def member?(%Zoo{title: _, animals: animals}, animal) do
{:ok, Enum.member?(animals, animal)}
end
end
end
Once again, note that the function accepts two arguments: an enumerable and an element. Inside we simply rely on the member?/2 function to search for an animal in the list of all animals.
So now we run:
Enum.member?(my_zoo, %Animal{species: "tiger", name: "Tigga", age: 5}) |> IO.inspect
And this should return true as we indeed have such an animal in the list!
Implementing the Reduce Function
Things get a bit more complex with the reduce/3 function. It accepts the following arguments:
- an enumerable to apply the function to
- an accumulator to store the result
- the actual reducer function to apply
What's interesting is that the accumulator actually contains a tuple with two values: a verb and a value: {verb, value}. The verb is an atom and may have one of the following three values:
:cont(continue):halt(terminate):suspend(temporarily suspend)
The resulting value returned by the reduce/3 function is also a tuple containing the state and a result. The state is also an atom and may have the following values:
:done(processing is done, that's the final result):halted(processing was stopped because the accumulator contained the:haltverb):suspended(processing was suspended)
If the processing was suspended, we should return a function representing the current state of the processing.
All these requirements are nicely demonstrated by the implementation of the reduce/3 function for the lists (taken from the docs):
def reduce(_, {:halt, acc}, _fun), do: {:halted, acc}
def reduce(list, {:suspend, acc}, fun), do: {:suspended, acc, &reduce(list, &1, fun)}
def reduce([], {:cont, acc}, _fun), do: {:done, acc}
def reduce([h | t], {:cont, acc}, fun), do: reduce(t, fun.(h, acc), fun)
We can use this code as an example and code our own implementation for the Zoo struct:
defmodule Zoo do
defstruct title: "", animals: []
defimpl Enumerable do
def reduce(_, {:halt, acc}, _fun), do: {:halted, acc}
def reduce(%Zoo{animals: animals}, {:suspend, acc}, fun) do
{:suspended, acc, &reduce(%Zoo{animals: animals}, &1, fun)}
end
def reduce(%Zoo{animals: []}, {:cont, acc}, _fun), do: {:done, acc}
def reduce(%Zoo{animals: [head | tail]}, {:cont, acc}, fun) do
reduce(%Zoo{animals: tail}, fun.(head, acc), fun)
end
end
end
In the last function clause, we take the head of the list containing all animals, apply the function to it, and then perform reduce against the tail. When there are no more animals left (the third clause), we return a tuple with the state of :done and the final result. The first clause returns a result if the processing was halted. The second clause returns a function if the :suspend verb was passed.
Now, for example, we can calculate the total age of all our animals easily:
Enum.reduce(my_zoo, 0, fn(animal, total_age) -> animal.age + total_age end) |> IO.puts
Basically, now we have access to all the functions provided by the Enum module. Let's try to utilize join/2:
Enum.join(my_zoo) |> IO.inspect
However, you'll get an error saying that the String.Chars protocol is not implemented for the Animal struct. This is happening because join tries to convert each element to a string, but cannot do it for the Animal. Therefore, let's also implement the String.Chars protocol now:
defmodule Animal do
defstruct species: "", name: "", age: 0
defimpl String.Chars do
def to_string(%Animal{species: species, name: name, age: age}) do
"#{name} (#{species}), aged #{age}"
end
end
end
Now everything should work just fine. Also, you may try to run each/2 and display individual animals:
Enum.each(my_zoo, &(IO.puts(&1)))
Once again, this works because we have implemented two protocols: Enumerable (for the Zoo) and String.Chars (for the Animal).
Conclusion
In this article, we have discussed how polymorphism is implemented in Elixir using protocols. You have learned how to define and implement protocols, as well as utilize built-in protocols: Enumerable, Inspect, and String.Chars.
As an exercise, you can try to empower our Zoo module with the Collectable protocol so that the Enum.into/2 function can be properly utilized. This protocol requires the implementation of only one function: into/2, which collects values and returns the result (note that it also has to support the :done, :halt and :cont verbs; the state should not be reported). Share your solution in the comments!
I hope you have enjoyed reading this article. If you have any questions left, don't hesitate to contact me. Thank you for the patience, and see you soon!
by Ilya Bodrov via Envato Tuts+ Code
#173: A Progressive Roadmap for your PWA
|
Chris Brandrick recommends
Brian Rinaldi recommends
Holly Schinsky recommends
by via Mobile Web Weekly
How to Improve Your LinkedIn Engagement
Want your LinkedIn posts to attract more viewers? Wondering how to increase views and shares of your LinkedIn content? In this article, you’ll discover five simple tactics to improve engagement on your LinkedIn posts. #1: Write Text-Only Posts You’ve probably heard that people engage more when a social media post shows an image or video. [...]
This post How to Improve Your LinkedIn Engagement first appeared on .
- Your Guide to the Social Media Jungle
by John Espirian via
World of Synesthesia
by via Awwwards - Sites of the day
Bobby Giangeruso
Brutalist One Page portfolio with a neat intro glitch-effect for Product Designer, Bobby Giangeruso.
by Rob Hope via One Page Love
Subscribe to:
Posts (Atom)