Giveaway: The Everyday Messenger Bag by Peak Design

Original Source:

Giveaway: The Everyday Messenger Bag by Peak Design

Giveaway: The Everyday Messenger Bag by Peak Design

Dec 11, 2017

It’s been a long time since our last giveaway on Abduzeedo, it’s quite exciting because we have one for you today. We are giving away to one lucky winner, the everyday messenger bag by Peak Design. We would love to give a huge shoutout to our friends from Peak Design for being so awesome! The rules are simple (right below) and international entries are welcome. Best of luck to everyone!

Everyday Messenger Bag

Giveaway: The Everyday Messenger Bag by Peak Design

The Rules

1. Subscribe to Abduzeedo Newsletter 
2. Like us on Facebook or Instagram 
3. –> Like @peakdesign on Instagram  That’s it! International entries welcome.

The winner will get to pick the size and colour of their choice. We will announce the winner on December 15, 2017

We partnered with renowned adventure traveler/photographer Trey Ratcliff to create one bag that adapts to your gear and lifestyle, no matter where you go or what you’re carrying. In doing so, we reimagined nearly every aspect of the classic messenger, from the MagLatch™ closure, to the origami-inspired FlexFold™ dividers, to the weatherproof expandable protective shell (400D nylon canvas) and hyper-adjusting internally padded seatbelt strap. Dedicated Capture clip attachment points and front access panel are designed for lightning-fast photography, drone, and everyday gear access. This bag is for creatives, travelers, commuters and everyone in-between. – Peak Design

About Peak Design

We are a design company—it’s in our name and in our blood. Our products must be innovative, beautifully crafted, and quite literally the best in their category. This is a high bar, but it provides necessary challenge and appropriate limits. Pursuit of this high standard gives us pride, satisfaction, the exuberance of mental strain, and many sleepless nights.

More Links
Learn more about Peak Design at
Follow Peak Design on Instagram
The Everyday Messenger Bag
Giveaway: The Everyday Messenger Bag by Peak DesignGiveaway: The Everyday Messenger Bag by Peak DesignGiveaway: The Everyday Messenger Bag by Peak DesignGiveaway: The Everyday Messenger Bag by Peak DesignGiveaway: The Everyday Messenger Bag by Peak DesignGiveaway: The Everyday Messenger Bag by Peak Design


holiday giveaway

Breaking the Grid Without Breaking Design

Original Source:

Symmetry is safe. It’s comfortable, non-threatening, and aesthetically pleasing. It can also be very dull. Using ‘asymmetrical balance’ can make things more interesting while still sticking to a grid to keep things ordered. In design, as in so many other things, the higher the risks the greater the potential rewards.

Symmetry has long been considered a good thing precisely because it is aesthetically pleasing and unchallenging to the eye. The word symmetry is derived from greek components which translate to ‘with measure’; symmetry is about proportion and balance, qualitative similarity as opposed to identical sameness. Asymmetry would therefore be a lack of balance or proportion, an unevenness.

In a visual context, however, most of us, even if we can’t remember taking basic geometry lessons (never mind what was in them) think of symmetry with a more restricted definition.

If something is symmetrical [has symmetry], it has two halves which are exactly the same, except that one half is the mirror image of the other.

-Collins dictionary

One very famous example of near perfect symmetry is the Rorschach Test cards. Their bilateral symmetry was a deliberate and important aspect of their appearance: Hermann Rorschach stated that many patients rejected asymmetric images. While the reasons for this might be an interesting area of study in itself, it’s a whole other article. All we need to know is: Symmetry comfortable; Asymmetry not so comfortable.

All we need to know is: Symmetry comfortable; Asymmetry not so comfortable

Asymmetrical balance, in a visual design context, is where two or more elements on either side of a plane are different but have the same visual weight. A simple example would be an image on one side with a block of text on the other, sized and styled to balance each other.

The two tools we use to create symmetry–and asymmetrical balance–in a design are the grid and our eye. The grid, as we know it is very much a mid 20th century invention, but in the same way that gravity already existed long before an apple fell on Isaac Newton’s head, so we can see evidence of grid based layout in some of the oldest surviving manuscripts we have: The Dead Sea Scrolls are written in even columns with regular margins and leading; the care taken over the positioning of illustration and text in early medieval manuscripts, such as the 8th century Book of Kells, indicates the use of a grid.

The grid is the bedrock of modern graphic design, and has been so for centuries in some form or other, long before the term graphic designed was coined. The grid ensures balance in a design by breaking up the ‘page’ into equal or proportional sections.

While the grid is objective, dividing space up based on exact mathematical proportions, the human eye is subjective. There are some guidelines or rules which apply for the vast majority, such as line length of x characters depending on device size, readable color contrast, all caps is a bit aggressive, and so on. But how a particular design is seen and received can vary greatly.

These variations range from the big (like the different meanings of colors across the world) down to the the individual variations of personal taste.

This is where a designer needs to have confidence; The courage to acknowledge that not everyone is going to love every design you do, and doing it anyway because it works. Knowledge and experience help, understanding why something doesn’t work means you understand how to fix it.

the grid is a tool that helps us, but we do not have to be bound by it

Sometimes, even though you know that an element is positioned correctly, or some leading is proportionally accurate according to your grid, somehow it just looks wrong. So you fix it by eye. You make adjustments until it looks right, until it feels right.

Our immediate response to design is emotional, the intellectual and analytical responses follow after. So we need to remember that the grid is a tool that helps us, but we do not have to be bound by it.

So, how can we break the grid, while still maintaining a coherent design?

Using Masonry

Probably the most frequently used technique is a masonry layout, like that made popular by Pinterest. The page is divided into regular columns along the horizontal plane, but the content blocks within those columns are of differing heights. Sometimes columns can be of double-or even triple-width, or an individual element may take up two or more column widths, but it will always be divisible by the single column width.

This technique can be applied the other way round—as in, content blocks of differing widths arranged into regular height rows—but it’s more commonly done as even columns. A masonry layout can, of course, be completely regular. If the vertical plane is divided into equal height rows and the height of each content block is a multiple of that row height then you have a masonry layout that sticks to the grid.

It is usual for the vertical spacing between elements is always the same, and matches the horizontal spacing between columns. If your content blocks contain text, making sure that the block height is consistent with your baseline grid can help with visual coherence.

Alliance Graphique Internationale

Alliance Graphique Internationale is a classic example of a masonry layout. The images are of equal widths, but differing heights while the vertical margins between images match the column gutters. All the images fill a single column width making it nicely responsive. An added touch is that the images load in randomly as you scroll down.   


L’ÉLOI’s layout has some double width content and uses a larger gutter size, both of which increase the impression of randomness. The greater space between elements emphasises the difference in their heights and vertical position.


Grafik’s layout takes things a bit further again. Like the two previous examples, the page is divided into equal columns, the number of columns being dependent on the width of the viewport. But there is no defined horizontal or vertical spacing between elements, and the images are not all sized to fill a full column width. The column widths are the same, but the horizontal space between items in each column is dependent on the size of the elements and the size of the browser window. The result feels interesting and random, while at the same time having a reassuring order that we are subconsciously aware of.

In addition, hovering over an image brings up it’s article title and an excerpt, which in a lot of cases overlaps adjacent images.


Repeating Irregular Pattern

Another technique is to create a repeating pattern of irregularly placed elements. The human eye is drawn to patterns, and our brains have a natural tendency to recognize patterns all around us. We instinctively seek out patterns because their predictability makes us comfortable.

Tom Dixon

Tom Dixon’s layout groups together several different sized elements, with varying horizontal and vertical space between them. The exact arrangement varies depending on screen size as the images scale at different rates. This ‘sub’ layout is then repeated with more content. It gives us the visual interest created by the irregular spacing and misalignment, but combines it with the reassuring symmetry of a repeating pattern.

Look Mom, (Almost) No Grid!

You can of course retrospectively apply a grid to almost any design. And even those designs that don’t appear to be grid based, almost always make use of an underlying grid, especially for their typography. However, as the whitespace around elements grows the grid becomes visually less and less dominant.

Ditching a grid based layout entirely is risky, but it can work in the right hands. Keeping things minimal and clean is an easier option to avoid grid geometry. This type of layout also works best with all images or at least predominantly images.


Sojournal pairs an image with a title and subheading. There is a slight pattern in that the images alternate between left and right placement. But the images are different sizes and proportions, and the exact placement varies from image to image. There are no defined columns and the vertical space between elements varies. 

The size of the images mean that no more than two are visible in the window at a time. It is a very clean, spacious feeling layout and the irregular positioning of the images focuses attention on each one in turn.


Because the images in Blacksheep’s layout are all of a similar—quite small—size, and are on the same subject theme they can be grouped together more closely, in some places even overlapping.  The overlaps are balanced out by the larger spaces in other places.

Hollie Fernando Photography

For Hollie Fernando’s portfolio, smaller images are placed closer together, while larger ones have more space around them. As with the two previous examples, the images here are carefully chosen and grouped. Content curation is always important for any site, but it is a vital part of a successful gridless layout.


p img {display:inline-block; margin-right:10px;}
.alignleft {float:left;}
p.showcase {clear:both;}
body#browserfriendly p, body#podcast p, div#emailbody p{margin:0;}

Master CSS Flexbox in 5 Simple Steps

Original Source:

CSS flexbox is an incredibly useful tool for layout without using floats or positioning. Currently almost all current browser version support flexbox, making it a go-to standard for web design. It can solve a number of problems efficiently, such as vertical alignment, space distribution, ordering of elements and sizing. It offers more freedom to arrange […]

The post Master CSS Flexbox in 5 Simple Steps appeared first on Web Designer Wall – Design Trends and Tutorials.

30 Stunning App Icon Designs You Need to See

Original Source:

Creating a good app icons design is challenging. The icon is a key visual element and it’s the first thing the users interact with. It should be beautiful, memorable, detailed, and the most important, it should reflect your design style. App icons is not a logo, but it has branding purposes. App icons should be placed into a square-canvas with specific size and context.

Here we have put together 30 stunning app icon designs which you would love to see. Some of them are simple and witty while other are complex with various design elements. Which one is your favorite?

1. Children’s help center — App icon


2. Bear Icon Design


3. Gallery Doctor app Icon


4. Love and Rockets icon design


5. Balloons design icon


6. Big boys play at night icon


7. Red Hills App Icon


8. Scary stories app icon


9. Teepee App Icon


10. Hatch app icon


11. New fork app icon design


12. Bag app icon design


13. Icon for Music Video


14. Monster Trucks Icon


15. Loose Leaf app icon


16. Electric range app icon


17. Cinnamon Roll App Icon


18. Pastry Icon


19. Pancakes App Icon


20. Electrics Old Fashioned Hot Dogs Icon


21. Egg icon design


22. Fried Egg Icon


23. Pizza app Icon


24. Bacon app icon


25. Krispy Kreme Icon Concept


26. Heineken Icon design


27. Heinz Ketchup Icon Design


28. Jack O’ Lantern icon design


29. Boxing glove app icon design


30. Oreo app icon design


Read More at 30 Stunning App Icon Designs You Need to See

8 New Courses for Developers & Designers

Original Source:

Each week Treehouse updates the library with new courses and workshops so that our students can continue their learning and stay up to date on the newest technology and languages. November was an exciting month as we released new design courses, a new language, and the completion of a brand new track. Data Analysis Basics is last course to complete our brand new Beginning Data Analysis track. Introduction to GraphQL is a brand new query language that can help simplify your workflow and compose more robust APIs. Check out the complete list of new courses below and explore learning something new!

Start learning to code today with a free trial on Treehouse.

1. Data Analysis Basics


Learn how to make better decisions with data in this course on data analysis with Ben Deitch. We’ll start by looking at what data analysis is, and then we’ll see how we can use data analysis to create better outcomes.

Check out the course here

2. Build a Selfie App

In this course with Pasan Permaratne we’re going to build an app that is quite popular these days – a selfie app! We’ll learn how to build and apply filters, how to use Core Data for more than just a single entity and how to use the device’s camera to create a fun app!

Check out the course here

3. Introduction to GraphQL


Simplify your backend with GraphQL, the new query language and runtime that is taking the world by storm. With GraphQL, it’s no longer necessary to resolve a bunch of different REST endpoints to get a complete chunk of data. We can use GraphQL to tell a server which data we want, and exactly what it should look like. Whether you’re a front-end developer looking to simplify your workflow, or a back-end developer looking for a way to compose more robust APIs, this course with Isaac Lee Morris is the perfect place to start.

Check out the course here

4. Digital Media Through Photoshop

Get started with creating your own digital media files. Setting up your documents properly before you start creating will be crucial for your end product. In this course with Shon Dempsey,  we’ll learn what those considerations are as well as how to choose the right options. We’ll introduce the most prolific creative application Photoshop to set up our files, make some adjustments and come out the other end with a banner ad suitable for use on the the desktop and mobile as well as print. This course is perfect for anyone looking to get started with design or photography.

Check out the course here

5. Prototyping with Figma

In this course with Nick Pettit, you’ll learn how to build interactive and sharable prototypes in Figma, a web-based visual prototyping tool. You’ll create a prototype for a “prosumer” mobile photography app, and by the end, you’ll have a better understanding of how to create interactive prototypes that can be shared with project stakeholders and team members.

Check out the course here

6. Active Record Associations in Rails

Most of your Rails models are going to be connected to other models in some way. An Author has many Articles, and each Article belongs to an Author. A Doctor has many Patients, and a Patient may have many Doctors as well. Rails uses associations to make it easy to track these relationships in your database. Learn about Active Record Associations in Rails in this course with Jay McGavren.

Check out the course here

7. What’s New in React 16


The new core architecture of React 16, codenamed “Fiber,” introduces lots of new, highly anticipated features and improvements to React. Get up to speed with new features in React 16 in this workshop with Guil Hernandez.

Check out the course here

8. Java Arrays

Arrays are container objects that can be used to store multiple values. In Java Arrays, we’ll talk all about what they are, how to create them, as well as why and when you should use them. Check out this course taught by Craig Dennis.

Check out the course here

Coming soon!
Build a Chatbot with Watson APIs

IBM has created an AI platform named Watson that gives businesses and developers access to powerful tools for text and speech analysis, computer vision, and more. Watson APIs consist of a suite of services used to process or analyze data to answer questions and make decisions. This course will show you how to build a chatbot with Node.js and Conversation services from Watson. You’ll also learn how to setup and deploy your bot on IBM’s Cloud platform.

Check out the upcoming course here

These are just a list of courses released this month. Our Treehouse Library currently has over 300 courses and workshops for you to check out!  Do you have a Treehouse favorite? Let us know in the comments below!

6 Design Courses to Get Your Creativity Flowing

The post 8 New Courses for Developers & Designers appeared first on Treehouse Blog.

Making your web app work offline, Part 1: The Setup

Original Source:

This two-part series is a gentle introduction to offline web development. Getting a web application to do something while offline is surprisingly tricky, requiring a lot of things to be in place and functioning correctly. We’re going to cover all of these pieces from a high level, with working examples. This post is an overview, but there are plenty of more-detailed resources listed throughout.

Article Series:

The Setup (you are here!)
The Implementation (posts tomorrow, stay tuned)

Basic approach

I’ll be making heavy use of JavaScript’s async/await syntax. It’s supported in all major browsers and Node, and greatly simplifies Promise-based code. The link above explains async well, but in a nutshell they allow you to resolve a promise, and access its value directly in code with await, rather than calling .then and accessing the value in the callback, which often leads to the dreaded “rightward drift.”

What are we building?

We’ll be extending an existing booklist project to sync the current user’s books to IndexedDB, and create a simplified offline page that’ll show even when the user has no network connectivity.

Starting with a service worker

The one non-negotiable thing you need for offline development is a service worker. A service worker is a background process that can, among other things, intercept network requests; redirect them; short circuit them by returning cached responses; or execute them as normal and do custom things with the response, like caching.

Basic caching

Probably the first, most basic, yet high impact thing you’ll do with a service worker is have it cache your application’s resources. Service worker and the cache it uses are extremely low-level primitives; everything is manual. In order to properly cache your resources you’ll need to fetch and add them to a cache, but then you’ll also need to track changes to these resources. You’ll track when they change, remove the prior version, and fetch and update the new one.

In practice, this means your service worker code will need to be generated as part of a build step, which hashes your files, and generates a file that’s smart enough to record these changes between versions, and update caches as needed.

Abstractions to the rescue

This is extremely tedious and error-prone code that you’d likely never want to write yourself. Luckily some smart people have written abstractions to help, namely sw-precache, and sw-toolbox by the great people at Google. Note, Google has since deprecated these tools in favor of the newer Workbox. I’ve yet to move my code over since sw-* works so well, but in any event the ideas are the same, and I’m told the conversion is easy. And it’s worth mentioning that sw-precache currently has about 30,000 downloads per day, so it’s still widely used.

Hello World, sw-precache

Let’s jump right in. We’re using webpack, and as webpack goes, there’s a plugin, so let’s check that out first.

// inside your webpack config
new SWPrecacheWebpackPlugin({
mergeStaticsConfig: true,
filename: “service-worker.js”,
staticFileGlobs: [ //static resources to cache

ignoreUrlParametersMatching: /./,
stripPrefixMulti: { //any paths that need adjusting
“static/”: “react-redux/static/”,



By default ALL of the bundles webpack makes will be precached. We’re also manually providing some paths to static resources I want cached in the staticFileGlobs property, and I’m adjusting some paths in stripPrefixMulti.

// inside your webpack config
const getCache = ({ name, pattern, expires, maxEntries }) => ({
urlPattern: pattern,
handler: “cacheFirst”,
options: {
cache: {
maxEntries: maxEntries || 500,
name: name,
maxAgeSeconds: expires || 60 * 60 * 24 * 365 * 2 //2 years
successResponses: /0|[123].*/

new SWPrecacheWebpackPlugin({

runtimeCaching: [ //pulls in sw-toolbox and caches dynamically based on a pattern
getCache({ pattern: /^, name: “amazon-images1” }),
getCache({ pattern: /book/searchBooks/, name: “book-search”, expires: 60 * 7 }), //7 minutes


Adding the runtimeCaching section to our SWPrecacheWebpackPlugin pulls in sw-toolbox and lets us cache urls matching a certain pattern, dynamically, as needed—with getCache helping keep the boilerplate to a minimum.

Hello World, sw-toolbox

The entire service worker file that’s generated is pretty big, but let’s just look at a small piece, namely one of the dynamic caches from above:

toolbox.router.get(/^, toolbox.cacheFirst, {
cache: { maxEntries: 500, name: “amazon-images1”, maxAgeSeconds: 63072000 },
successResponses: /0|[123].*/

sw-toolbox has provided us with a nice, high-level router object we can use to hook into various URL requests, MVC-style. We’ll use this to setup offline shortly.

Don’t forget to register the service worker

And, of course, the existence of the service worker file that’s generated above is of no use by itself; it needs to be registered. The code looks like this, but be sure to either have it inside an onload listener, or some other place that’ll be guaranteed to run after the page has loaded.

if (“serviceWorker” in navigator) {

There we have it! We got a basic service worker running, which caches our application resources. Tune in tomorrow when we extend it to support offline.

Article Series:

The Setup (you are here!)
The Implementation (posts tomorrow, stay tuned)

Making your web app work offline, Part 1: The Setup is a post from CSS-Tricks

The Internet of Conference Tables

Original Source:

At One Mighty Roar, we’ve spent a lot of time thinking about how to tackle physical and digital overlap. After creating a textable office sign, a logical next step was to tackle our conference table. We wanted to bring conference furniture to the next level — and to do that, we were going to need lights, proximity sensors, and a “can do” attitude.

The Goal

To spruce up our meetings we wanted a table that not only was classy but served as a memento for our office. We wanted a table that knows if someone is present, is easily accessible over the web, and can show off its lights and hydraulic lift on command. This table would be one of the first stepping stones towards our hackable office.

The Table

With a surface composed of sweet American walnut and was crafted by our friends at Erik Rueda Design Lab. It’s no surprise that our team was huddled in the conference room for an hour admiring the view (we also suddenly became very strict about our drink coasters rule).

Just like most tables in existence, ours has four legs as support, but these aren’t just any normal table stands. If you take a closer look, we found that our logo actually serves as a great reinforcement for table tops.

On top of all of that, our table also comes equipped with some LED housing that runs through the center and around the bottom of the surface. The lights we chose were Adafruit’s WS2801 LEDs so we could easily slap on an Arduino and start programming away.

Finally, the centerpiece is not just a placeholder for our logo, it serves a much greater purpose:

A hydraulic engine lifts up the piece to expose a collection of outlets and Ethernet jacks for laptops and alike to receive some juice. A small switch at the bottom of the table controls the centerpiece vertically, so hopefully we’ll install some sensors to ensure a power cable (or a hand for that matter) will never get crushed in the process.

The Work

After some brainstorming and coffee-sipping, I found some downtime during the week to hack away at this side project. Since we already had an awesome setup for our sign, I began to adapt and expand this codebase for the conference table.

To get started, I gathered up some supplies:

Arduino Uno
Arduino Ethernet Shield
HCSR04 Ultrasonic Sensor
Various wiring and power supplies

For libraries we used:

Adafruit WS2801 Library

As a quick proof-of-concept, we had previously implemented a RESTful API for our office’s sign, using Webduino.

Once the “tableduino” API library was banged out, the setup was as simple as attaching the Arduino Ethernet shield and wiring the Ultrasonic sensor to the board. We gave the Arduino some power and an Ethernet hookup then started to fire away some API calls.

Here are some of our requests and results!

POST /m-animate
Red = 255
Blue = 0
Green = 0
action = line-fill


POST /m-animate
Red = 255
Blue = 255
Green = 0
action = fade


POST /b-animate
Red = 255
Blue = 255
Green = 0
action = detect-mode

Making cURL requests or using Postman to hit these endpoints is nice and all, but co-worker Trevor Suarez also created a web GUI to easily interact with the sign and the table using your phone. In the coming weeks we plan on expanding this app for all of our office devices.

You can grab the code for the table from the GitHub repo here.

The Future

What we have so far is only the beginning of what we want to accomplish with our office devices. Down the road we want our API to control the table’s hydraulic motor, halt the engine if an object is detected before closing, and change LED color as more individuals sit at the table.

These are only a few of the possibilities we could think of for the time being. We’re sure as more people play with our table (and possibly hack themselves) in the next few months, there will be more ideas than we’ll know what to do with.

Learn How to Build a Chatbot with IBM Watson APIs

Original Source:


We’re excited to announce that Treehouse has partnered with IBM on a new course called Build a Chatbot with Watson APIs. Watson is the AI platform for business from IBM (made famous by its appearance on Jeopardy! in 2011), and it’s a collection of AI services designed to work together. If you’re new to AI, you might be wondering why it matters or how you can use it yourself. Below is my own explanation, and the course can help take you even further.

Start learning to code today with your free trial on Treehouse.

From protein folding, to Twitter, to stock markets, the amount of data in the world is growing at an unprecedented pace; there’s no way for humans to sift through it all. This is a problem, because our ability to turn raw data into useful information and knowledge is a limiting factor on the pace of technology and innovation.  If the world is generating more data than we can interpret, then we’re not getting the full value from the data or reaching our full potential. In many cases there are low consequences to slower data processing, but as someone that lives in Florida where we get hurricanes annually, I depend on computer models and human experts to predict the path and severity of each storm in real-time. If more sophisticated models and better predictions are available, there would be less guesswork when making preparations, and hopefully a less severe aftermath.

Even when we apply clever algorithms, it’s extremely difficult to create the perfect set of rules for interpreting and understanding a given data set. For example, let’s say we want to create an algorithm that’s capable of identifying a piece of fruit from a photograph. Maybe we could create rules to identify a fruit based on its shape. But then, what if the photo is taken at a strange angle (for example, the silhouette of a pear is similar to other spherical fruit from a top-down perspective)? Then, maybe we could add rules to identify the fruit based on color. However, what if a banana is transitioning from yellow to brown, or what if there are green apples instead of red apples, or what if the photo is in black and white?

Sure, it’s probably possible to come up with a rule set that will work, but it could be hundreds of rules and branching decision trees, and that’s just for identifying one type of thing. This is the type of problem that can be addressed by machine learning. Rather than telling a computer to check a set of rules created by a human, we instead “train” the computer on a set of a data and it writes the rules itself. In most cases this still involves a human to build an initial data set and work with an artificial intelligence to guide it to the initial correct answers, but after viewing enough different photos of fruit, the AI will start to gain more confidence in its own predictions.

Image recognition and computer vision is just one application of AI. Similar principles of machine learning can be applied to problems like speech recognition, natural language processing, and much more. In the Treehouse course Build a Chatbot with Watson APIs, you’ll create an AI that you can talk to in the same way you might chat with someone over an instant messaging service. This type of “chatbot” can assist businesses that need help with customer service, but may not have the capacity to answer a high volume of customers, or want to offer assistance outside of normal business hours; a chatbot never has to sleep. Just like AI, chatbots also have broad applications – for example, perhaps someday we might interact with domain-specific chatbots rather than using so many different phone apps.

If you want to browse some of IBM Watson services before getting started, head over to Then when you’re ready to start creating, check out the Build a ChatBot course!

The post Learn How to Build a Chatbot with IBM Watson APIs appeared first on Treehouse Blog.

Desktop Wallpaper Calendars: April 2012

Original Source:

No April Fools joke today. Instead let me present a roundup of Desktop Wallpaper Calendars for April 2012. With spring in full swing, I’ve gathered several beautiful desktop wallpapers featuring April 2012 calendars. Freshen up your desktop and check back next month for a brand new calendar update.  Feel free to share these with your friends and email me if you ever would like your calendar featured in a similar roundup.

6 Beautiful Desktop Wallpaper Calendars for March 2012
Wallpaper by Ibrandstudio

Wallpaper by Paper Leaf

Wallpaper by MonkeyMan504

Wallpaper by Shrimp Salad Circus

Wallpaper by Webgranth

Wallpaper by Studio of Mae

Wallpaper by Kriegs

The post Desktop Wallpaper Calendars: April 2012 appeared first on Visual Swirl Design Resources.

6 Must-Have Tools in a PHP Developer’s Toolkit

Original Source:

PHP is a popular back-end programming language that allows you to quickly and effortlessly create simple, dynamic websites. It’s so popular, in fact, that around 80% of all websites now use it! Once you’ve decided to learn PHP and join the awesome community of developers, you may be wondering, what are some essential tools I’ll need? We asked expert PHP teacher, Alena Holligan to share her top picks!

Start learning to code today with your free trial on Treehouse.

Reference documentation

The first and most fundamental tool you should have at your disposal as a PHP developer is the documentation manual bookmarked in your browser or downloaded to your desktop. This go-to resource will cover everything PHP from installation and configuration to a full list of language references and features. As a developer, don’t expect to be able to remember everything (no one can!), but keeping this manual handy is a great way to look something up quickly.

Access or download the manual here.

Be part of the collaborative GitHub community

Octocat via GitHub

GitHub is a collaborative development platform built on top of a distributed version control system called Git. As a PHP developer – and any developers for that matter – GitHub can be the most valuable place for you to share & collaborate with other developers. If you’re new to GitHub, we also recommend checking out the GitHub Basics course on Treehouse to learn how to navigate the GitHub site, explore open source software, and best practices.

Sign up for GitHub here.

Rely on Xdebug to exterminate bugs

Xdebug is a great debugger and profiler tool for PHP. Use it to test your code and assist with debugging and development. Trust us, it’ll save you valuable time and avoid unnecessary frustrations!

Install Xdebug here.

Master management with Composer

php developer's toolkit

Composer is a dependency manager for PHP that allows you to manage both dependencies of PHP software and required libraries in one place, saving you time and effort. Since the software’s initial released in 2012, it has literally changed how PHP is developed and is a popular choice among the PHP community, from beginners to pros.

Download Composer here.

Testing, testing with PHPUnit

If you’re going to write unit tests in PHP, look no further. PHPUnit is a programmer-oriented unit testing framework for PHP and is a favorite tool with our teachers for writing unit tests in PHP. It’s flexible, powerful and easy to use. The great news is that we teach a course on PHP Testing with guest teacher, Chris Hartjes and there’s even a section specifically about using PHPUnit!

Get started with PHPUnit here.

Tap into the power of PHPStorm

php developer's toolkit

PHPStorm is an awesome super tool. It’s a PHP IDE from JetBrains that can also integrate with the other tools we’ve mentioned above. PhpStorm works with frameworks like Drupal, WordPress, Laravel, Magento, CakePHP, and the list goes on… With built-in developer tools, you can also carry out routine tasks right from the IDE. With so many capabilities, the editor is also able to truly understands your code and offers valuable code completion, error prevention, and more to help you code efficiently and productively.

Learn more and buy PHPStorm here to start coding.

BONUS: Join Local User Groups

Another top tip from Alena is to make an effort to connect with local PHP user groups. The PHP community is awesome, welcoming and supportive, and always happy to welcome new members. So how do you find your local group? Easy, just head on over to to access every PHP-Usergroup worldwide, find your local group and sign up for their next event!

These are only a few of the PHP tools out there, we’d love to hear what you would add to the list in the comments below!

8 Must-Have Tools in a Beginner Developer’s Toolkit

The post 6 Must-Have Tools in a PHP Developer’s Toolkit appeared first on Treehouse Blog.