text:
Until now, using a computer usually meant interacting with a conglomeration of metal, silicon and other materials that could more or less clearly be perceived as a computer. Even smartphones – the latest step in the evolution of computers – are rather clumsy to use, if you think about it.
Perhaps the most striking way to see the difference between regular computers and wearables is the user's posture when using the computer. Using a computer results in a more or less non-natural posture or – even worse – behaviour (see Curious Rituals for a look in the mirror).
Wearables change this. By being attached to or located closely to your body, they allow you to take up a much more natural posture and eventually (in the more or less distant future), people around you will no longer notice them.
Granted, in their current incarnation, many wearables are still a long way from this vision and it is remains to the readers imagination how long you can wear a VR device like the Oculus Rift without getting a sore neck or becoming nauseous. However, this is only just the start and we will see great progress in the following years.
On March 18th, Google announced Android Wear and released the Android Wear Developer Preview. Shortly after that, Motorola announced their Moto 360 watch which generated quite some excitement on the internet. On the same day, LG announced their LG G watch – a rectangular model.
Android Wear is Google's second platform for wearable devices (Google Glass being the first one). The theme for both platforms is to bring useful, contextual information to users when they need it. Ultimately, the goal is to empower users without distracting them.
If you're excited about Android Wear as well, here are some ideas for you to try out.
Sign up for the Developer Preview. Head over to our developer site and sign up for the Developer Preview. When signing up, please make sure to use the same Gmail account you use on your Android device – this will make it much easier for you to download the Android Wear Preview beta app to your phone or tablet. As soon as you've been accepted to the preview, you will receive a confirmation email that outlines how to opt-in to the Android Wear Preview app beta program. You'll need this app in order to connect your Android Wear simulator to your device.
Follow the instructions for setting up the Developer Preview on your developer machine as described in Getting Started with the Developer Preview. Here are a few things to make sure it all works out fine:
The great thing about Android Wear is that your app's notifications will show up on any connected Android Wear device (or emulator, for that matter) without any further effort. So, if you have an app that uses notifications to alert the user, you should be able to see those notifications on the Android Wear Emulator as soon as you have connected the Emulator to your Android device (phone or tablet) running your app. If you don't have an app that uses notifications, you can quickly check this out by sending an email to the Gmail account cyou use on your device so the notification for the email pops up in the notification center.
Notifications are one of the two major design principles of Android Wear: Suggest and Demand.
All notifications will end up on the context stream, which is a vertical list of cards, much like Google Now on Android phones. The user can interact with the cards by swiping them vertically, thereby navigating the stream of important information. Due to the limited screen real estate, only one card will be displayed at a time. You can add cards to the context stream by creating and delivering notifications. Use NotificationCompat.Builder to create basic notifications (make sure to use the one in the Android Wear Preview SDK, otherwise some features will not work). To use Android Wear specific features like pages or actions, or to customize the look of cards on the context stream, use WearableNotifications.Builder. Here is a short snippet that shows how to create a notification:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
Whenever you create notifications, be sure to follow the [Android Wear Design Principles](http://developer.android.com/wear/design/index.html. In particular, you should make sure all information you deliver follows the principle of being timely, relevant, and specific.
Android Wear is not just about displaying notifications that the user can then interact with. In addition, users can initiate an interaction with their device by using the cue card. The cue card is brought up by saying "OK Google" or tapping on the "g" icon on the home stream of the device. Swiping up on the cue card will reveal a number of actions that can be executed by tapping them or speaking them. Voice actions are not yet available in the current preview SDK.
As the name implies, the Android Wear Developer Preview is not intended for creating production apps at this time. The APIs might change significantly prior to the official release of Android Wear. The preview is intended for development and testing purposes only. Also, we're interested in your feedback, so make use of the Google+ community and Stack Overflow.
(or a developer who wants to understand the design ideas behind Android Wear)
Read the Android Wear Design Principles.
Become a member of the Android Wear Google+ Community to get in touch with fellow developers / designers and share your ideas.
A few people have created some great design resources for Android Wear. If you're interested in creating some mock-ups, check out +TaylorLing's Android Wear UI Design Kit for Photoshop. If you want to add some more glitz, head over to +SpiderflyStudios and download their Moto 360 mockups. Photoshop is not your thing? Check out Frank Erlich's OmniGraffle stencil.
Please note that the current SDK focusses entirely on notifications. Refer to the Design Principles of Android Wear for a good overview of the Notifiaction UI Patterns available. Let this be your guide when using the design resources I linked. Not everything that's possible in Photoshop might be possible with the current SDK.
…here is the link to the music used in the video: Chromeo – Jealous (I Ain't With It)
I am excited to announce I have started a new job with Google!
Starting January 20th 2014, I'll work as a Developer Advocate on the Google+ team at Google in London. Many people have asked me what a Developer Advocate actually is and what we do, so I'll briefly explain it here for everyone's benefit.
The official job posting for Developer Advocates at Google says:
We're self-proclaimed nerds, and our Developer Relations organization helps keep us connected to the communities that love technology as much as we do. Developer Advocates are focused on supporting the 3rd party developers who are building applications and businesses on Google's platforms. You are passionate evangelists for Google technologies as well as vocal champions for developer interests within Google. This is a position for engineers who love connecting with developers and speaking publicly about cutting-edge technologies on conference panels, at user groups, on blogs and with the press. Chrome, Android, App Engine, HTML5 as well as our core Google Apps and Ads APIs are just some of the platforms you promote and support.
As a part of that, I'll be working together with a whole bunch of other Developer Relations staff to help 3rd party developers and partners to use the Google+ Platform and APIs to integrate their apps and services with Google's platforms. The term "Advocate" means I'll act as a two-way communication channel: on one hand, I will speak at conferences, write blog posts and articles to communicate how to use Google APIs. On the other hand, I am here to listen to the feedback user of our APIs give and make sure this gets fed back into the product life cycle. This means I will meet with a lot of partners and developers, listen to their needs and gripes and help them to make sense of our APIs
If you are interested in a more in-depth explanation or if you're even considering becoming a Developer Advocate yourself, I can recommend Christian Heilmann's excellent book on this topic.
That being said, feel free to reach out to me on Twitter, Google+, or by email if you are interested in using the Google+ platform and becoming a platform partner. If you've got any technical questions, check out our excellent and friendly communities on Google+ and StackOverflow. If there is anything in particular you would like me to have a look at, ping me on Google+. When reporting a problem, keep in mind the guidelines for writing great bug reports and also keep Mano Marks' post on How to Approach a Google Developer Advocate with Questions in mind – help us to better help you :–)
Lastly – we're hiring: check out Google Jobs!]]>
Runscope is an online tool for inspecting, debugging and testing API traffic. The traffic inspector allows you to easily set up a "wire tap" for your app, basically allowing you to monitor and record any traffic between your app and any API that you're using. In addition to recording traffic for inspection, you can also compare responses of two calls and find out where the differences are – very handy! You can even share individual recorded requests with your co-workers, e.g. to discuss a problem with your back-end team.
Runscope also provides a tool for automated testing of your API, dubbed Runscope Radar. This tool allows you to set up a sequence of API calls, along with the expected outcome for each of the calls. Radar provides an easy-to-use UI for setting up simple, yet powerful assertions that allow you to specify how the header and body of the response should look like. Variables help you to keep things flexible. Runscope Radar supports JSON and XML, so it is easy to build expressions like
[2].number to navigate JSON and XML responses and specify expectations. You can then schedule your tests to run at given intervals and be notified via e-mail in case a test fails. This allows you to easily set up intelligent tests that monitor the validity of your API.
Wiretap by Kris Jordan looks very promising as well. It acts as a reverse proxy, allowing you to record HTTP traffic between your app and an API very easily. In fact, setting up a wiretap seems to be easier than setting up Runscope. Unfortunately, still is in beta, but Kris has set up a video to give you a goood understanding of how it works. Wiretap and Runscope look strikingly similar, but I have the impression Wiretap has been around for longer…
Christmas is upon us – and this is your chance to give back some love to some of the many open source projects out there you might be using in your own work. The idea is to submit one pull request each day for any project on Github. A number of projects are already listed on the projects page, which allows you to filter projects by programming language to find a few that you might be interested in. Your favourite project isn't listed? No problem at all – just submit a suggestion and fork away!
I found it very interesting to see Xtend is officially listed as a programming language on Github – great job, guys!
If you wanted to use JavaScript in your iOS apps prior to iOS 7, you basically had two options: use an embedded
UIWebView and invoke
-stringByEvaluatingJavaScriptFromString:, or recompile JavaScriptCore for iOS.
Starting with iOS 7, Apple opened access to JavaScriptCore (I really like "For information about the classes of this framework, see the framework header files."), basically enabling iOS developers to use JavaScript to script their applications.
The NodeApp interpreter goes one step further and allows developers to re-use existing Node modules. Even if you might not be interested in using any of the 50.000+ module listed on npm.org, this is good news as it allows you to re-use the Node module system, thereby enabling you to structure your JavaScript apps in a more concise way.
Check out the NodeApp interpreter app and impress your coworkers with a real JavaScript interpreter running on your iPhone!
Racer is a Chrome Experiment that shows off various web technologies, like WebSockets, the Web Audio API, CSS Animations and CSS Sprites.
Watch the making of, read the back story of how it was made on HTML 5 rocks. Then, go find some friends with mobile devices and play Racer online. The soundtrack has been composed by Giorgio Moroder, who composed a number of well-known songs for events like Olympia 1984 and 1988 or the 1990 Football World Cup. Some of his songs were used in racing games before, but the soundtrack for Racer is the first one to be composed specifically for the purpose of being used in a racing game.
I hope you enjoyed this week's links – let me know if you would like me to continue compiling them by sending me a mail or – better yet – using the tweet button below to let your friends know about this post!
Thanks for reading!]]>
We all know testing is essential to verify the behaviour of the software you write. In the Android world with its huge variety of devices and OS versions, this is even more so. Unfortunately, the performance of the Android development environment, most notably the Android Emulator, leaves much to be desired which sometimes leads to neglicence of test discipline. Robolectric is a test framework that tries to alleviate this situation.
Robolectric achieves this by sitting between your code and the Android OS code intercepting calls and redirecting them to shadow objects, making it possible to run your tests inside a regular JVM. This effectively means you can run your tests on your desktop – no waiting for your code to be deployed to the Emulator or a physical device!
For more detailed background information about the inner workings of Roboloectric, check out this presentation and this talk by Tyler Schultz, one of the committers of Robolectric.
As the blog title implies, this time around, we'll use Eclipse to create our project under test. Make sure you're using the most recent version of the Eclipse ADT, which is part of the Android SDK. If you don't have it already, Google provides a nice all-in-one download of the SDK here.
Create a new project, using the following settings:
API 8: Android 2.2 (Froyo)
API 18: Android 4.3
API 19: Android 4.4 (KitKat)
Choose to create a custom icon and a custom launcher and place the project in a location of your liking.
On the Create Activity page, choose Blank Activity, and on the Blank Activity configuration page use the following settings:
Main Actity
To make things a bit more interesting, let's change the UI so we've got a
TextView, an
InputView and a
Button on, just like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
To prepare your project for testing with Robolectric in Eclipse, there are a few things you need to do:
The great thing about Robolectric is your tests are plain JUnit tests, so there is no need to run the tests on a device or the Emulator. This means we can use a plain Java project to host our tests.
By now, you might be wondering why we don't use Maven to set up our dependencies. To cut a long story short: setting up an Android project in Eclipse is a lot easier without using Maven. The downside of this approach, however, is that we have to manage project dependencies ourselves.
Head over to Maven Central to fetch the latest version of Robolectric including dependencies (at the time of this writing, Robolectric 2.2 was the most up-to-date version).
RobolectricDemoProjectEclipseTests, create a new folder
libs and add the downloaded jar file by dragging it to the folder. After that, right-click the added file in Eclipse and choose Build Path –> Add to Build Path to add it to the build path.
Later, we will use FEST Android to write our test assertations in a fluent way, so we need the required jar files and add the to the project as well.
As JUnit is the base for all our unit tests, we need to add it to our classpath, too. Open the project's properties, navigate to Java Build Path –> Libraries and click on Add Library…. In the next dialog, choose JUnit and press Next. Finaly, choose JUnit 4 (Robolectric relies on JUnit 4) and press Finish.
Finally, we need to add the Android library itself as a dependency to our test project. To do this, open then project properties dialog (Right-click the test project, select Properties) and navigate to Java Build Path. In the dialog, click on Add External JARs… and navigate to
<Android SDK>/platforms/android-19/android.jar to add the latest Android jar to the projects build path.
Because of the way Robolectric looks for your
AndroidManifest.xml during test startup, it won't find the manifest if your tests and the manifest are located in different projects.
Robolectric supports configuring individual tests using the
@Config annotation, allowing you to use a different manifest file depending on the test you run. This can be quite handy, but it is a good idea to have a default configuration. Starting with version 2.0, Robolectric supports a global configuration using a config file.
To specifiy a manifest file, place a file named
org.robolectric.Config.properties in the root of the
src tree of your test project, so it can be discovered by Robolectric during test setup and add the following line:
This will tell Robolectric to use the
AndroidManifest.xml file from our Android project under test.
Let's write our first test! Add the following class to
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Please note that we added a simple test method, making sure it will fail. Why is this a good idea? Well, it makes sure our test fails when running it, so we can be sure the whole setup actually works. If we run the test and it does not fail, we know that something is wrong.
So, let's run the test! Right-click on the test file and choose Run As –> JUnit Test. As a result, you should see the test bar turn red in the JUnit view.
The test failed – just as expected. You can turn it into a passing test by changing the assert statement to
Now that we've got everything in place, let's develop a small feature in a test-driven way. You already noted how we enhanced the UI of the application at the beginning, but apart from looking nice, there's not much functionality.
Let's enhance the app so the user can enter their name, press a button and be greeted by the application.
Make sure to statically import the Android FEST assertations – they'll help us to write our tests in a fluent manner:
As we need to have access to the app's main activity in all of our tests, let's add a private field for it and create a setup method that will create a fresh activity before each test is run:
1 2 3 4 5 6
It is a good practice to ensure the UI is fired up and all UI elements have been initialized as expected (i.e. are not null):
1 2 3 4 5 6 7 8 9 10 11 12 13
Next, let's write a test that places a text inside the edit field, presses the button and compares the result in the text view with the expected result.
Here is the test method:
1 2 3 4 5 6 7 8 9 10 11
When you run the test, it will obviously fail, so let's fix this.
MainActivity.java and insert the following private class:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
As you can see, this code will register an
OnClickListener for the button and set the text of the text view according to the value of the edit field.
The test should now pass – just run the unit test again and you should see a green bar.
Setting up an Android project for using Robolectric in Eclipse is quite a bit of work, as you just have seen, but it's reasonably easy with the information I have given you above. Adding Robolectric to a new Android project is just a matter of minutes with these instructions and helps you save a lot of time you'd have had to spend otherwise running the tests on the emulator or on physical devices.
You might be interested in checking out my recent post on integrating Robolectric in a Gradle-based Android project in Android Studio – this way, please.
Here are the slides I used for presenting this topic at Eclipse Democamp November 2013 in Hamburg:
The source code for this blog post can be found on Github – clone and enjoy!]]>
Sometimes, you are responsible for a bug, sometimes bugs are in a third party library you use in your project. And sometimes, the documentation of an API doesn't match the implementation, giving you funny results for code that slavishly adheres to the official documentation.
With the following techniques, you'll be able to go hunting for bugs and find out where they came from. Once you've found out (and fixed the bug), you should consider writing a unit test to prevent future regressions. So, here we go.
Most developers are familiar with the concept of breakpoints, but if you're new to Xcode you might wonder how to create or modify a breakpoint, so I'll give a brief overview.
You can create a breakpoint by clicking on the line number in the editor gutter. The breakpoint will be displayed as a solid blue indicator in the gutter. From that moment on, your application will pause execution as soon as execution reaches the breakpoint.
There are a few ways to manipulate breakpoints:
To temporarily disable the breakpoint, just click on the breakpoint indicator, which will then turn light blue to indicate it is disabled.
To remove a breakpoint, drag it off the editor gutter, making sure to crank up the volume to enjoy the swooshing sound ;–)
Breakpoints have properties that you can edit by right-clicking on a breakpoint indicator. Selecting the Edit Breakpoint menu will display a tool window which allows you to customize various aspects of a breakpoint, effectively turning a breakpoint into a conditional breakpoint:
The various properties of a conditional breakpoint allow you to specify exactly under which circumstances execution should stop at the breakpoint. What's more, you can specify certain actions that should take place when the breakpoint criteria are met.
For example, in order to stop execution inside a
tableView:cellForRowAtIndexPath: method when the table view controller requests the cell for the 3rd row, add this condition:
indexPath.row == 2
Of course, you can specify more complex conditions as you see fit.
Something which is unique to Xcode is the option to execute a certain action whenever a breakpoint is hit. There are a number of interesting actions, such as:
Of all those options, speaking a message or playing a sound stand out the most. While you might think these are just toys, they are actually very useful in combination with the option to continue execution after hitting the breakpoint.
Just consider for example an app that waits for the arrival of a background signal while the user does something in the app. Now, if you place a breakpoint on the line that receives the background signal and configure the breakpoint to play a signal or speak a message, you can go on and exercise the app in the foreground while waiting for the background message to arrive. As soon as the message arrives, you'll hear the sound play and can take appropriate actions.
Exception Breakpoints are a very powerful tool – basically they allow you to spot places in your code where an exception is thrown (and not caught). So instead of just marvelling at a crash in
main.m, add an Exception breakpoint to your project (by clicking the tiny
+ icon on the bottom of the breakpoints view).
Symbolic breakpoints are useful when you want to stop in a piece of code that you don't have source code for. Let's say you're interested in who (and when) calls
tableView:numberOfRowsInSection. Just create a new symbolic breakpoint, using the symbol
tableView:numberOfRowsInSection. The debugger will now break whenever any piece of code in your app sends this very message – no matter if it's your code or code from a third party.
As soon as your application has hit a breakpoint, you can start inspecting its current state. Most likely, you'll use the Debug area at the bottom of the Xcode window to do so.
However, sometimes it can be tedious to click-navigate through a deep hierarchy of nested properties. This is when the debugger console comes in handy. It is located on the right hand side of the debug area. Just click inside the white space and type a command. When debuging Objective-C code for iOS, you're most likely using lldb. Former versions of Xcode used gbd as their default debugger. A comparison of lldb and gdb, including a list of commands they support can be found here. A more in-depth documentation of lldb can be found here. Don't worry – you do not have to wade through all of this documentation, I'll give you a run down of the most important commands here:
If you want to peek inside an object, you can use the
po (print object) command:
(lldb) po index
You can dig deeper into objects, like this:
(lldb) po todo.title
Eat an apple
Say you want to print the contents of a variable which isn't an object, for example the length of the string in the previous example. Using the
p (print) command you can print the value of primitives such as integers or constants:
(lldb) p i
You can even invoke methods:
(lldb) p [todo.title length]
If you quickly want to change the value of a variable without having to restart your app, use the
expr (expression) command:
(lldb) expr todo.title = @"Changed"
(NSString *) $6 = 0x0c139a80 @"Changed"
The current stack can be printed using the
bt (thread backtrace) command:
(lldb) bt
* thread #1: tid = 0x1e05f, 0x0000381a TodoMobile`-[TodoListViewController tableView:cellForRowAtIndexPath:](self=0x0c795c40, _cmd=0x00fcbadf, tableView=0x0e25e400, indexPath=0x0c7f95e0) + 138 at TodoListViewController.m:67, queue = 'com.apple.main-thread, stop reason = breakpoint 1.1
frame #0: 0x0000381a TodoMobile`-[TodoListViewController tableView:cellForRowAtIndexPath:](self=0x0c795c40, _cmd=0x00fcbadf, tableView=0x0e25e400, indexPath=0x0c7f95e0) + 138 at TodoListViewController.m:67
frame #1: 0x0094e61f UIKit`-[UITableView _createPreparedCellForGlobalRow:withIndexPath:] + 412
frame #2: 0x0094e6f3 UIKit`-[UITableView _createPreparedCellForGlobalRow:] + 69
frame #3: 0x00932774 UIKit`-[UITableView _updateVisibleCellsNow:] + 2378
frame #4: 0x00945e95 UIKit`-[UITableView layoutSubviews] + 213
frame #5: 0x008ca267 UIKit`-[UIView(CALayerDelegate) layoutSublayersOfLayer:] + 355
frame #6: 0x01b0381f libobjc.A.dylib`-[NSObject performSelector:withObject:] + 70
frame #7: 0x048062ea QuartzCore`-[CALayer layoutSublayers] + 148
frame #8: 0x047fa0d4 QuartzCore`CA::Layer::layout_if_needed(CA::Transaction*) + 380
frame #9: 0x047f9f40 QuartzCore`CA::Layer::layout_and_display_if_needed(CA::Transaction*) + 26
frame #10: 0x04761ae6 QuartzCore`CA::Context::commit_transaction(CA::Transaction*) + 294
frame #11: 0x04762e71 QuartzCore`CA::Transaction::commit() + 393
frame #12: 0x0481f430 QuartzCore`+[CATransaction flush] + 52
frame #13: 0x0087bdc9 UIKit`_afterCACommitHandler + 131
frame #14: 0x01d364ce CoreFoundation`__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__ + 30
frame #15: 0x01d3641f CoreFoundation`__CFRunLoopDoObservers + 399
frame #16: 0x01d14344 CoreFoundation`__CFRunLoopRun + 1076
frame #17: 0x01d13ac3 CoreFoundation`CFRunLoopRunSpecific + 467
frame #18: 0x01d138db CoreFoundation`CFRunLoopRunInMode + 123
frame #19: 0x03a3f9e2 GraphicsServices`GSEventRunModal + 192
frame #20: 0x03a3f809 GraphicsServices`GSEventRun + 104
frame #21: 0x0085fd3b UIKit`UIApplicationMain + 1225
frame #22: 0x000032dd TodoMobile`main(argc=1, argv=0xbfffedc0) + 141 at main.m:16
If you're not happy with the level of tool support Xcode provides you with, I recommend taking a look at AppCode – its debugger is a lot more powerful. However, it currently lacks support for sound breakpoints ;–)
If you're interested in learning more about debugging iOS apps in general and some tools that might come in handy, check out this presentation:
Also, Heiko Behrens and I had a chat about debugging iOS apps – it is available as an episode of the excellent (ok, I am biased) podcast UISprech (in German only, sorry) here: UISprech #7: Debugging Tools mit Peter Friese.]]>
Robolectric achieves this by sitting between your code and the Android OS code intercepting calls and redirecting them to shadow objects, making it possible to run your tests inside a regular JVM. This effectively means you can run your tests on your desktop – no waiting for your code to be deployed to the Emulator or a physical device!
For more detailed background information about the inner workings of Roboloectric, check out this presentation and this talk by Tyler Schultz, one of the committers of Robolectric.
To better understand how Robolectric works, let's create a very simple project we'll use as our object under test. We'll use Android Studio (at the time of writing, version 0.3.0 was the latest version).
Create a new project using the settings you can see in the following screenshots. Choose Blank Activity and Navigation Type None.
To make things a bit more interesting, let's change the UI so we've got a
TextView, an
InputView and a
Button on, just like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
To prepare your project for testing with Robolectric, there are a few things you need to do:
When you create a new project in Android Studio, it is not yet configured for testing. If you used to develop Android apps in Eclipse, you probably are used to creating a new project for your tests. The good news is, with the new Android build system based on Gradle, you can now place your tests in the same project as your production code (refer to the build system documentation for more details).
However, Android Studio (and the Gradle Plug-in) currently expect you to place tests in
src/instrumentTest. As we won't be writing instrument tests, we'd rather like to place our tests in
src/test. In order for this to work, we need to tell Gradle and Android Studio we're deviating from the default project structure:
src/test/java to contain your tests.
build.gradle in your project folder and add the following source set configuration to the Android plug-in configuration, right beneath the
defaultConfig configuration:
1 2 3
Tools -> Android -> Sync Project with Gradle Files from the main menu. This will tell Android Studio where to find your test files.
You will notice how the icon for your test files folder turns from orange to green:
In order to be able to run Android unit tests with Gradle, we need to add the Gradle Android Test plug-in to the build script.
1 2 3
Add the plug-in to the dependencies section of your
classpath 'com.squareup.gradle:gradle-android-test-plugin:0.9.1-SNAPSHOT'
Apply the plug-in:
1 2 3 4 5 6
build.gradle should now look like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
Because of the way Robolectric looks for your
AndroidManifest.xml during test startup, it won't find the manifest if your tests are located in
src/test/java. To alleviate this situation, we need to add a custom test runner.
Add the following file to your project, making sure to place it somewhere in the
test tree:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
Let's write our first test! Add the following class to
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
A couple of things to note here:
Firstly, we use the newly created
RobolectricGradleTestRunnerto make sure the test can access the Android manifest (and thereby the other Android components in your app).
Secondly, we added a simple test method, making sure it will fail. Why is this a good idea? Well, it makes sure our test fails when running it, so we can be sure the whole setup actually works. If we run the test and it does not fail, we know that something is wrong.
So, let's run the test!
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
So, the test failed – just as we expected. You can open the test report (
../RobolectricDemoProject/RobolectricDemo/build/test-report/debug/index.html) in your browser to get more detailed information about the test run.
Now that we've got everything in place, let's develop a small feature in a test-driven way. You already noted how we enhanced the UI of the application at the beginning, but apart from looking nice, there's not much functionality.
Let's enhance the app so the user can enter their name, press a button and be greeted by the application.
Make sure to statically import the Android FEST assertations – they'll help us to write our tests in a fluent manner:
As we need to have access to the app's main activity in all of our tests, let's add a private field for it and create a setup method that will create a fresh activity before each test is run:
1 2 3 4 5 6
It is a good practice to ensure the UI is fired up and all UI elements have been initialized as expected (i.e. are not null):
1 2 3 4 5 6 7 8 9 10 11 12 13
Next, let's write a test that places a text inside the edit field, presses the button and compares the result in the text view with the expected result.
Here is the test method:
1 2 3 4 5 6 7 8 9 10 11
When you run the test, it will obviously fail, so let's fix this.
MainActivity.java and insert the following private class:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
As you can see, this code will register an
OnClickListener for the button and set the text of the text view according to the value of the edit field.
Also, change the constructor of
MainActivity so it uses the new fragment class when instantiating the view fragment:
1 2 3 4 5
The test should now pass:
1 2 3 4
Setting up Robolectric so that you can use both Gradle and Android Studio may not be as simple as it should be, but it's reasonably easy with the information I have given you above. Adding Robolectric to a new Android project is just a matter of minutes with these instructions and helps you save a lot of time you'd have had to spend otherwise running the tests on the emulator or on physical devices.
The source code for this blog post is available on Github.]]>
The main goal of this library is to provide animations in listviews, but it also comes with a great implementation for a UI pattern that most users know from the GMail app: swipe to delete with undo. Rather clumsy name, but it does exactly what's written on the label: the user can swipe a list view item to either side of the screen in order to delete it. But instead of deleting it right away, ListViewAnimations will display a cell with an undo button, allowing the user to change his mind. Integrating it in your apps is straightforward, check out the wiki for further information.
The number of mobile phones per capita seems to keep growing and a surprising large number of countries in this list have a ratio of more than 1:1. Many of these phones aren't being used at all and lead a boring life in a dark corner in the back of a drawer of your desk. Wouldn't it be great if we could use our phones longer than just a few years, thought Dave Hakkens and jotted down his ideas for a reusable, upgradable phone. A great idea, although there are good reasons why it might not work out at all.
Just recently, my colleague Stefan Grasmann pointed me to a very interesting Hanselminutes episode in which Scott Hanselman and Dr. Neil Roodyn talk about vision-based input devices such as Kinect and LEAP Motion. Scott pointed out he had been rather underwhelmed by the user experience of the LEAP, mostly because it requires you to perform rather precise motions instead of the more coarse-grained motions that Scott would like to use. In this video, Elon Musk demonstrates how to use the LEAP to design rocket part prototypes using hand gestures.
Designing rocket engines might not be your cup of tea, but if you want to get your hands on one of those devices, you can either buy a regular LEAP at Amazon or wait for the HP Envy Leap – a Laptop by HP with a built-in LEAP controller
That's it for this week, folks. Enjoy the weekend and create some awesome stuff!]]>
Great source of information on everything travel-related. Whether you are considering traveling in business class rather than economy, need background information about visas or the lowdown about cities such as London, Berlin, Hamburg, or New York, WikiTravel has you covered. I found the information on the cities to be largely up-to-date and of great value (at least for the cities I know, it seems to very accurate), so it's worth checking out before your next travel.
The Mac doesn't have a central repository that keeps track of everything you install. If you install software via the Mac App Store, it will be listed in the Mac App Store App (what a word!), but at least if you are a developer (and if you are a regular reader of this blog I assume you are), you'll install software via HomeBrew, the Mac installer and several other means. Now, how did you nstall that particular version of Gradle? Was it HomeBrew? Or did it come as an installer package? Or did you maybe just download and extract a zip file? This answer on Stack Exchange lists several ways to find it out.
A nice collection of pictures from Nokia's device testing lab. I'm tempted to call this the "Device Torture Chamber". If you're not so much interested in testing devic hardware, but rather software, you should have a look at these, too: * Mobile Test Lab by Etsy * Mobile Test Rig by Zühlke
If you use Git and haven't heard about Git Flow, you must have been living under a rock. Atlassian, makers of the excellent Git / Hg client SourceTree, have been so nice to put together an overview of all the various Git workflows, such as the Centralized Workflow, the Feature Branch Workflow, the Forking Workflow and the Gitflow Workflow. If you're looking for a good overview or a refresher, have a look.
Today (September 13) is Programmers's Day! If you like cocktails, check out this collection of cocktails created just for celebrating programmers around the world! I haven't tried any of these, but Memory Leak looks nice. If you missed Programmers' Day (it's on the 256th day of the year), you might want to make a note in your diary for 2014. Programmers' day will be on Saturday, September 13, 2014.
That's it for this week – enjoy the weekend!
Chains image by Haya Bernitez]]>
Brought to you by FileSquare, this little web site allows you to create good looking product images of your app inside a real phone frame. As of now, MockUPhone has mockup frames for most (but not all) iOS devices and some Android and Windows Phone devices. Basically, you just upload one or screenshots of your app and – after some crunching – you can download a zip archive that contains your screenshots inside the selected phone cases. You need to provide an e-mail address to download the archive.
Currently, the site is a bit sluggish – maybe due to heavy load. Also, there is very little room for tweaking how the result looks like. Check out ShapeItApp by Heiko Behrens for a similar service that is more flexible and let's you tweak the result before you download it. Also, it would be impossible to talk about mock-up services and not mention PlaceIt by Breezi
Some Github related data mining. Enter your Github user name and the site tries to come up with some smart statements about your coding behaviour. Dan uses some Python scripts to extract data from the Github Archive. The code is available on Github for your enjoyment.
iOS developers are a blessed bunch of people – not only do we have a decent dependency management tool, but also do we have CocoaControls, a never-ending inspiration for new controls, libraries and apps (ever wondered which components your favorite app uses? Head over to the apps section).
For a long time, Android developers didn't have outlets like these. Well, fear no longer, Nadav Fima has you covered. AndroidViews offers a nicely organized view into the universe of views, animations, libraries, development tools and other resources. If you have a component that is not yet listed, drop him a mail.
Don't just drink coffee. Also have a glas of wine every now and then to spark your creativity.
Chains image by Haya Bernitez]]>
With the release of iOS 7 just around the corner, you might be wondering which devices you should test your apps on in order to make sure you cover all required combinations of services that might or might not be available to your app (yes, iOS 7 is one of those releases that won't make all features available on all devices). Cult of Mac has a nice overview chart, worth checking out.
Github has made it really easy to check out new libraries or demos: just clone the repo and off you go. But what about creating new projects? If you find yourself constantly creating new projects, adjusting the build configuration to suit your needs, adding a Podfile for CocoaPods, then Crafter might be for you. You can configure it with your defaults, while at the same time staying flexible by adding options. Definitely worth a try.
Most apps require you to map data from a text-based presentation (mostly JSON or XML) to Objective-C objects. Chances are you've written mapping code by hand in at least one of your projects. "Its's just one or two classes, how hard can it be?", was probably what you thought when you set out to implement you home-grown mapping. YOu might have ended up with either pulling your hair out while maintianing your code whenever the API team decided to implement some "minor changes" or using a full-blown framework like RestKit that gave you more than you needed. If you just need to map data without the need for all the fancy add-ons like automatic CoreData persistence, in-memory and persistent caching and so on, you should have a look at the following frameworks. The all follow different approaches, some apply automagic mapping by matching field names, others by using an internal DSL to help you express your mapping. Take a look yourself and decide based on what you need for your current project.
Did you ever wonder how to create those geeky looking source code screenshots that look like you used a camera to take a picture of your screen from an angle? Well, here's a tool that let's you create those screenshots without the need to take out your camera: Instacodes
That's it for this week, I hope you liked it. Feel free to send suggestions for next week!
Chains image by Haya Bernitez]]>
As an iOS developer, you rely on a surprisingly high number of Apple systems. Until recently, there wasn't a way to find out if a system was offline or if it was just you, "holding it wrong". As an immediate response to the (alleged) hack of their developer support systems, Apple shut down pretty much all of their developer support systems and set up this system status page. As of now, all systems are back to normal, but this page might come in handy for future outages.
Due to popular belief, Ariane 5 exploded because a programmer mixed up a comma with a period, but it's not that easy,
In fact, the problem was someone used a 16 bit unsigned integer variable to hold the result of converting a 64 bit floating point value. I guess this is strong point for using type safe languages in safety-critical systems as well as clearly stating the pre- and post conditions of library functions. Some unit tests might also be in good order.
A talk Bret Victor gave at the DropBox conference in
1973 2013 on how he thinks the future of programming could have looked like if developers had been more courageous in embracing new ideas instead. Instead, we often see people rejecting new ideas, stating "that's not real programming". Thankfully, every now and then new ideas are strong enough to gain enough traction. Otherwise, we'd still be writing code in binary. Recently, we've seen a growing interest in programming languages and programming paradigms other than the well-known object-oriented / procedural approaches. I think this is a good sign, however, we need to be more open minded and think more about other, new ways of programming. If you haven't done so in this year, you should set aside some time to learn a new programming language. Why not try Xtend?
If you develop software for a living, you know that following a coding style guide makes sense. Sometimes, people do get religious about how to format their code – try to steer clear of this by using a widely-regarded style guide. The NYTimes Objective-C Styleguide is well-written, has the right amount of concise examples and can be forked in case you feel you need to adjust something to your liking. The fact that the New York Times mobile team welcomes contributions will probably make this styleguide one of the more popular ones.
Whether you just want to quantify yourself, something which Stephen Wolfram seems to be doing to quite some extent or you're curious what secret services might know about you if they installed a keylogger on your system: SelfSpy is a good tool to get started: it runs on Linux, Windows and Mac OSX. Besides, it's open source – so you can see what it does and you can extend it if needed.
Chains image by Haya Bernitez]]>
Despite some initial issues with the wifi, the organizers did a great job: from drinks and snacks to the sponsored vouchers for selected restaurants in the O2 arena, you couldn't wish for better catering for hackers. Those who stayed for the sleep over even got the treat of a late-night pizza delivery – hacker's delight! Power strips were available at every desk and – after some initial hick-ups – the WiFi was available throughout the venue. Best conditions for productive work!
The sponsors had not only made sure to equip everyone with a branded T-Shirt, but also had brought a generous supply of gadgets and other toys to hack on, such as Makey-Makey kits (provided by MailJet), Windows 8 Licenses (Nokia / Microsoft), numerous Hue kits (courtesy of Philips, who later told us this had been their first ever sponsored hackathon – well done, guys!). Plenty of toys to spark some creative ideas!
Official hack time went from Saturday noon to Sunday noon, which should be enough time to build something awesome.
Unfortunately, there was no team-building phase, so you either had to come with your team, find some team mates by chance or run on your own. I decided for the latter.
Inspired by Microsoft's challenge ("build something awesome with Windows Phone 8, Windows 8 or Windows Azure services"), my initial idea was to build a translation app for Windows Phone 8. Unfortunately, two things put a spoke in my wheel: the evening before the hackathon, I installed Windows 8.1 Preview in a VMware Fusion instance, but it just wouldn't connect to my Lumia 920 test device via USB. What's more, the Windows Phone 8 emulator refused to start – the reason being it needs Hyper-V support which isn't activated by default for virtual machines on VMware Fusion. Later that day, I found out how to configure VMWare Fusion and Windows 8 so that the Emulator does run, however I had made up my mind and had started implementing the app on iOS.
In contrast to Windows Phone 8, iOS doesn't feature a speech SDK (which is kind of funny, given Siri has been a part of iOS for a number of releases now), so you have to use a third party SDK for voice recognition and speech synthesis. As I had evaluated a number of speech SDKs when I started work on ElizaApp, I knew already which of the current speech SDKs would fit the bill and decided to use Nuance Speech SDK. For translating the recognized text fragments, I decided to use Google Translate (which is a paid service now, by the way). In order to make things more challenging, I decided to use not only one phone for the whole translation process, but two.
The flow of events for a simple dialog is outlined in the figure below: first, both users need to choose their preferred language on their phones, while their phones register with the BabelPhone backend server. Then, the first dialog partner taps the "speak now" button to initiate speech recognition and starts speaking. As soon as he stops speaking or taps the "speak now" button again, the speech recognition engine analyses his utterance (as we're interested in detecting natural language as opposed to simple commands, voice recognition will actually take place on a server, in our case provided by Nuance) and tries to detect what the user said. The recognized text will now be sent to the BabelPhone server.
As both communication partners registered with the server when the conversation started, the server knows them, as well as their language preference. Thus, the server can now send the recognized text to Google Translate and have it translated to the target language. As soon as Google Translate returns the translated text, the server can send it to the second user's phone, where it will be converted to spoken text using the Nuance Speech SDK.
As communication between the server side part of the application and the smartphones receiving the translation needs to take place in an asynchronous manner, we need a suitable communication channel. Web sockets lend themselves perfectly for this purpose: they offer a permanently open communication channel between server and client while at the same time being rather lightweight and ensuring a low-latency delivery of messages.
The whole process of recognizing the users utterance over sending it to the backend server, having it translated, sending it back down to the second phone and converting the translation back to spoken language usually takes less than a second under good circumstances, allowing for a more or less fluent conversation.
Apart from a low at around 3 o'clock in the morning and a power nap at 6 am, I had quite a productive stride with implementing my ideas, and I finished almost on time shortly past 12:00 on Sunday.
After everybody left the room who wasn't going to present a hack (for space reasons, only one member of each team was allowed to present) and everybody had grabbed a quick lunch, presentation of the hacks began. The organizers had redecorated the stage so that 6 teams could set up their demo simultaneously and wait until it was their turn to present. This way, transitions between the individual presentations were cut to a minimum.
More than 60 teams presented their work, with results being really impressive throughout. A list of all hacks presented can be found on Hackerleague.org. My favorite hacks were:
Live demos have their special challenges, which is why most speakers tend to avoid them – nothing is more boring for the audience (and at the same time more nerve-racking for the presenter) if a demo just stops working and the presenter starts looking for the cause live on stage. A Hacked.io, every presenter had to present a live demo – slideware was strictly prohibited. I was quite surprised to see the vast majority of demos worked flawlessly without apparent issues. More stuff, less fluff – that's what makes it even more interesting and engaging for the audience!
My demo went very well, too. I was lucky enough to have done a test run just a few minutes before the live demo, as I found out I had run out of Nuance credits, resulting in my app neither recognizing any speech nor uttering anything. Fortunately, I could buy additional credits on the spot and make the demo work literally minutes before going on stage!
After all teams had presented their demos, the jury gathered for finding their verdict and decide on who should receive one of the numerous prizes. The sponsors did it in style and had brought a range of attractive prizes, among them several LEGO Star Wars Death Star models, Philips Hues kits, vouchers for services like Heroku or Github, tickets for events at the O2 arena and more.
Apparently, the name of my hack ("BabelPhone") evoked sweet memories with the jury – at least I was awarded a Yahoo-sponsored gift voucher for Amazon. Later, the Yahoo jury members told me my hack reminded them of the legendary Babelfish service – one of the first ever publicly available translation services on the internet.
After having been awake for roughly 36 hours, I immediately fell asleep as soon as I collapsed in my bed. Hacked.io certainly was an exhausting, but also very rewarding experience. A huge thanks to all the organizers, volunteers, sponsors and all the other attendees – it was a blast!
Finally, here is a list with upcoming hackathons and other hack events:
BTW, if you plan attending a hackathon and need a team member wo is skilled in iOS / Windows Phone / Android / Node.js development, give me a shout (@peterfriese) – if I am available and your idea sounds cool, I'll join you!]]>
In all of these movies, humans can directly communicate with computers using voice commands ("Tea. Earl Grey, hot") or more elaborate sentences and the computers will talk back to humans as a result. In some of the movies, the computer is a non-bodily entity (like the ship's main computer in Star Trek), but sometimes it even is humanoid (like Cmdr. Data in Star Trek or the Replicants in Blade Runner).
In a Pecha Kucha presentation I recently delivered at the OOP conference in Munich, I took on this theme and started my talk with a imaginative conversation between two computer programs that most of you might know very well: Eliza and Siri.
In this Pecha Kucha session, Siri and Eliza join me live on stage to explain why we do not (yet) use the potential of our smart phones.
Much has been said about Siri, so let's focus on Eliza.
Eliza started as an experiment in 1964, when Joseph Weizenbaum, then professor of computer sciences at the MIT, wrote it as an early attempt to research natural language communication between man and computer (see his ACM paper "ELIZA – A Computer Program For the Study of Natural Language Communication Between Man And Machine"). At its heart, Eliza is program that reacts to specific key words in sentences entered by a human user and will then respond to those keywords according to a predefined script. It's the script that basically makes up the "personality" of Eliza, the most famous one being Doctor, simulating a rogerian psychoanalyst.
(Weizenbaum was rather surprised to see how people thought that Eliza had a real personality and a capacity for empathy. In reaction, he started to raise uncomfortable questions about our dependence on computers.)
In my Pecha Kucha, I went on to tell my audience to make better use of the capabilities of our smart phones. Most people have stopped thinking about it, but after all, we're carrying a super computer in our pockets.
So to set a good example, I decided to create ElizaApp – an app that can listen to what you say and answer in spoken language. This is going to be a great project, because I'll show several very interesting things:
How to analyse spoken language on a mobile device
How to synthesize speech on mobile devices
How to integrate a JavaScript engine in your mobile app
How to create a Siri-look-alike chat UI
Over the course of the next few weeks, I will write several posts covering these topics. If there is anything that interests you in particular, feel free to add a comment.
Of course, in the end Eliza will be available on the App Store. In the mean time, be sure to check out ElizaApp and register for early access!]]>
Over the years, implementing scope providers has become significantly easier, much thanks to the tiny internal scoping DSL provided by
org.eclipse.xtext.scoping.Scopes (src). However, collecting the elements that make up a scope can be a very cumbersome task if you have to use Java. Let's face it – Java has not been built for traversing models.
A language much better suited to traversing models is Xtend, the newest kid on the X block. If you didn't yet give it a try, you should do so now – even if you're not writing an Xtext DSL. Xtend directly translates to Java code and allows you to write very concise code by eliminating much of Java's ceremony. You can use it to write everything you'd write in Java – from Android UIs to web applications – so why not write Eclipse plug-ins with Xtend?
To write the scope provider for your language using Xtend, you need to follow a few very simple steps:
Disable generating the scope provider stub. Open
Generate<YourDSL>.mwe2 in the DSL project and find the line
fragment = scoping.ImportNamespacesScopingFragment { }
Change this line to
fragment = scoping.ImportNamespacesScopingFragment {
generateStub = false
If you already have a Java-based scope provider, copy the implementation to a safe place and delete the Java file to make room for the new Xtend-based scope provider.
Create a new Xtend class
<YourDSLPackage>.<YourDSL>ScopeProvider.xtend in the DSL project. Make sure this class inherits from
Start writing your scope provider using Xtend.
Don't forget to smile :–)
Wouldn't it be awesome if you could just specify a list of dependencies and be done? You might have heard of RubyGems, Maven, Ivy, NuGet or npm that bring dependency management to the worlds of Ruby, Java, .NET and JavaScript developers.
Well, it turns out there finally is a solution for us Cocoa developers – CocoaPods. Getting started with CocoaPods is really easy and once you started using it, you won't look back again.
CocoaPods itself is distributed as a Ruby gem, so installing it is as simple as:
1 2
Using CocoaPods to manage your project's dependencies is a two-step process:
pod install
Let me illustrate this by way of a simple example. Let's assume you want to build an application with the awesome RestKit library. If you have used RestKit before, you know that adding it to your project is a rather involved process. Over the years, it has become significantly easier, but it still needs a very detailed installation instruction with lots of screenshots – check out their wiki page.
With CocoaPods, all you need to do is this:
1 2 3 4 5 6 7 8
pod install RestEasyWithCocoaPods.xcodeproj
1 2 3 4 5
Wasn't that a lot easier than all the other ways to install third party libraries?
If you are curious which libraries are supported by CocoaPods, go to CocoaPods.org – they have a nice little UI for searching their pod specification repository. If you are more include to using the command line, you are welcome to use
pod search <yoursearchterm> to search for a specific library.
If your preferred library is not yet supported, why not help them out and build a pod spec? CocoaPods itself and the pod spec repository are hosted on Github, so adding new pod specifications is really easy. The CocoaPods wiki has a section on creating and publishing new podspec files.
Now go and create awesome stuff!]]>
Starting with iOS 5, Apple has introduced an official API for accessing Twitter from your iOS applications. Before iOS 5, integrating Twitter in your apps was a rather cumbersome experience which required us developers to jump through many hoops.
In this post I want to outline the most important features of the iOS Twitter and Accounts APIs and explain how to use them to write a decent Twitter client for your next app in very few lines of code. The full source code is available on Github for your convenience.
The Accounts and Twitter frameworks perform much of the heavy lifting required when talking to Twitter, such as
Lots of free stuff, so let's have a look at how much (or little) code we actually need to write to tap this source of awesomeness.
The Accounts Framework provides access to all Twitter accounts the user has added to their iPhone using the settings app. Currently, the Accounts Framework only supports Twitter accounts, but you'll soon realize it has been build so that it basically can be used to access any other kind of account in future releases. Maybe the next version of iOS will provide easy access to Google+ and Facebook accounts – we'll see.
To use the Accounts and Twitter frameworks, we need to add them to the project:
Once that's done, we can use the Accounts framework to fetch the list of Twitter accounts on the device.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
Just like many other new APIs that perform potentially blocking I/O, the Accounts framework uses blocks to execute your code as soon as the data you requested is available. When querying the accounts database, we can specify the kind of accounts we're interested in –
ACAccountTypeIdentifierTwitter in our case. If we're granted access to the accounts database, we fetch the list of accounts using
accountsWithAccountType:. As soon as we've got this list, we want to save it in a ivar / property and update the UI. Since there is no guarantee we're on the UI thread when our completion handler is run, we use
dispatch_sync to ensure assigning the list of accounts and updating the UI is run on the UI thread (
dispatch_get_main_queue() returns the GCD queue of the UI thread). For more information on blocks and Grand Central Dispatch (GCD) check out this excellent blog post.
Displaying the accounts in a
UITableViewController is straightforward:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
When the user selects one of the accounts, we want to display a list of recent tweets for this selected account. We'll use
TWRequest to fetch the list of recent tweets.
TWRequest is the centerpiece of the iOS Twitter Framework and relieves us of the burden of having to perform OAuth authentication and request signing on our own. In order for it to do this, we need to provide a reference to the account whose timeline we want to read. We also need to provide the URL of the Twitter API endpoint we want to access. While this might seem a little bit cumbersome at first, this allows us to access not only current API calls but also any new APIs Twitter might come up with in the future without requiring Apple to update the API. Pretty nifty.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
Again, we need to provide a completion handler which will be invoked as soon as the call to Twitter returns. As you can also see, we're using the same approach as before to make sure we update the UI from the UI thread. It's also interesting to see Apple provides us with their own JSON parsing framework – no longer do we need to integrate third party libraries to serialize / deserialize JSON data.
So far, we can choose a Twitter account from the list of Twitter accounts on our iPhone and display the home timeline of this particular user. But how about sending a tweet?
Sending tweets is really easy: you just have to instantiate a new
TWTweetComposeViewController and display it – iOS will take care of the rest:
1 2 3 4 5 6 7 8 9 10
The completion handler is merely needed to dismiss the tweet composition view after the tweet has been sent.
Integrating Twitter in your own apps has never been easier. With just a few lines of code, we implemented a basic version of a Twitter client that you can use to display a user's home timeline and send tweets. Elaborating this code base is left as an exercise to you – feel free to fork the code on Github and send me pull requests as you add interesting features!
Here's an impression of the current state of the application:
Well, we've come a long way since then and computers are more powerful than ever before. I remember using one of the first versions of IBM ViaVoice which would quite literally bog down my computer when I tried using it. The quality of speech recognition software has vastly improved and using a clever stack of technology, you can even use speech recognition on your iPhone (the actual recognition is performed on a server, but the effect is stunning nevertheless).
With all the hoopla around HTML 5, it would be quite a surprise if modern browsers didn't have something in store with regard to voice recognition. And sure enough, there is a W3C specification for a Speech Input API. Looking at the list of authors might give us a hint as to which browser might support this API…
Using the speech input API is rather easy. All you have to do is to add the
x-webkit-speech attribute to any
input tag and you're done. If you're on a speech-enabled browsers (as of this writing, only Chrome 11 supports this out of the box), you can check it out in the input field below. Just click on the microphone icon and start speaking:
So, the other day I thought, "wouldn't it be cool if I could use voice recognition to look up my contacts on the social networks I am on?". Adding voice recognition support to a website you own is rather easy, as you only have to add the
x-webkit-speech attribute to the respective input fields. Enhancing foreign sites, however, turns out to be a little bit more involved. Fortunately, Chrome can augment existing websites by way of so-called Content Scripts, which are a part of the Chrome Extensions API.
Writing a Chrome Extension for speech-enabling existing text input fields on just about any website was a matter of minutes, thanks to the good documentation and some jQuery to walk the DOM. Putting on the finishing touches took me some more time, and I am proud to present you Speak to Search – a Chrome Extension that lets you talk with your browser. It works with virtually every website that uses regular HTML input fields. By making some smart assumptions, the extension will automatically submit the current form if the input field is a search field. If it is not, the focus will remain in the field and the form will not be submitted. That way, you can fill out e.g. an address form.
Here is a short video of me using Speak to Search to search for some people on Xing and LinkedIn. Please note that the extension is making sure the speech recognition engine is configured to recognize German names on Xing.
Language makes us human – this is a quote from a video I found during the research for this blog post. I don't necessarily think voice recognition and speech synthesis will make computers more human, but both technologies certainly can help to create a more immersive experience. I am looking forward to seeing a broader use of the new audio capabilities of modern browsers. Feel free to grab my code from Github and create something new and exciting!]]>
Quite a number of my colleagues at itemis have been busy preparing for this conference in the past few weeks. Besides working hard to hit the Eclipse Release Train milestone for Indigo on June 22nd, the Xtext team brushed up their hands-on sessions "Xtext Take I: Creating Code Generators with Xtend2" and "Xtext Take II: Crafting Domain Specific Languages with Xtext and Xbase". If you've been using Xtext, you're well aware of the power you have at your disposal with this tool. Xbase and Xtend2, however, take this experience to a whole new level. So make sure to mark your calendar for these two sessions!
But not only the Xtext team will share their expertise at CG2011 – Markus and Karsten will be also be in town to give hands-on tutorials and report from their experience:
The finale of the conference will be a panel discussion hosted by Markus on the topic of "Models, DSLs, Transformations: The Next 5 years" – this should be a very interesting and lively discussion!
Heiko and I will present "Cross-Platform Mobile Development with DSLs" – a fast-paced and fun mixture of slides, live coding (or modeling, if you will), videos and audience interaction. Yes, that's right – the audience will be part of the show. Make sure to bring your web-enabled mobile phone and get the chance to win a price!
To keep track of the conference program(me), we at itemis mobile have been busy to create a conference planner for your iOS and Android powered mobile phones. Here are the download links:
If you like the apps, please use the feedback feature of the respective store. Got comments or suggestions for improvement? Drop us a note or track us down at the conference (best chance to see us: come to our talk ;–) ).]]>
Even on your local computer, you use services like Spotlight or the search field in your mail application all the time. Apps that lack decent searching and filtering capabilities sometimes are really hard to use, so as developers we should spend some time on thinking how to allow users to filter the data they're dealing with.
In this post, I am going to focus on ways to filter data. We won't be looking at the UI side of things – this is something I'll do in a subsequent blog post.
If you look at an arbitrary code base, chances are you'll sooner or later run into a piece of code similar to this one:
1 2 3 4 5 6
It's a straight-forward approach to filtering an array of items (in this case, we're talking about books) using a rather simple
if-statement. Nothing wrong with this, but despite the fact we're using a fairly simple expression here, the code is rather verbose. We can easily imagine what will happen in case we need to use more complicated selection criteria or a combination of filtering criteria.
Thanks to Cocoa, we can simplify the code by using NSPredicate.
NSPredicate is the object representation of an if-statement, or, more formally, a predicate.
Predicates are expressions that evaluate to a truth value, i.e.
true or
false. We can use them to perform validation and filtering. In Cocoa, we can use
NSPredicate to evaluate single objects, filter arrays and perform queries against Core Data data sets.
Let's have a look at how our example looks like when using
1 2 3
Much shorter and better readable!
Regular Expressions can be used to solve almost any problem ;–) so it's good to know you can use them in
NSPredicates as well. To use regular expressions in your
NSPredicate, you need to use the
MATCHES operator.
Let's filter all books that are about iPad or iPhone programming:
1 2 3
You need to obey some rules when using regular expressions in
NSPredicate: most importantly, you cannot use regular expression metacharacters inside a pattern set.
Let's for a moment assume you want to filter all books that have been published by your favorite publishers. Using the
IN operator, this is rather simple: first, we need to set up a set containing the publishers we're interested in. Then, we can create the predicate and finally perform the filtering operation:
1 2 3 4
NSPredicate relies on key-value coding to achieve its magic. On one hand this means your classes need to be KVC compliant in order to be queried using
NSPredicate (at least the attributes you want to query). On the other hand, this allows us to perform some very interesting things with very little lines of code.
Let's for example retrieve a list of books written by authors with the name "Mark":
1 2 3
In case we'd want to return the value of one of the aggregate functions, we don't need to use NSPredicate itself, but instead use KVC directly. Let's retrieve the average price of all books on our shelf:
The Cocoa libraries provide some very powerful abstractions which can make your life and that of the people reading your code much easier. It pays off to know about them, so go ahead and browse the Cocoa documentation and hunt for those gems!
Apple's NSPredicate programming guide provides an in-depth documentation for
NSPredicate containing all the things I didn't cover in this post.
NSPredicate also plays an important role when querying data in Core Data, something we will need to have a look at in one of the next blog posts. Stay tuned!
The code for this post is available on my github page: get forking!]]>
This year, we're providing a rather impressive lineup of mobile apps for iPhone, iPod Touch, iPad (thanks to Christian Campo who created a stand-alone iPad app), BlackBerry (Ekke is working on a updated version, AFAIK), and all other smart phones that feature a browser.
All apps allow you to browse the program, select your favorite talks and get to know the speakers (with headshots so you recognise them in the hallways). We also have included maps of the convention center as well as Santa Clara.
For a first glimpse, watch our video:
As of today, both iPhone and Android users can download the apps from the Apple App Store respectively the Android Marketplace. Here are the links:
If you don't own an iPhone or Android, you can always use the HTML-only version of the conference program available at http://bit.ly/econ2011html.
The iPad and BlackBerry apps will be available soon, so stay tuned!
By the way, if you run a conference and are interested in having an app like this, get in touch with us.]]>


text:
By Kevin Chiu
On September 26th, 2014, thousands of Hong Kong citizens united to boycott China's decision to disallow open nominations for the 2017 Chief Executive election. They rallied for freedom, declaring themselves independent of China, as the 'Hong Kongese'. Chinese police reacted with hostility, using pepper spray and excessive force against the protesters. Because both sides are unwilling to reach a compromise, a "new era of civil disobedience" is emerging, gaining both domestic and foreign supporters.
"There is no doubt that strong and influential supporters will aid the Hong Kong protesters overseas because of the power of media, however Chinese suppression will ultimately prevent any domestic alliances," states Elizabeth Johnson, an American History teacher.
Hong Kong was acquired by the British through the Opium Wars, but returned to China in 1997. A two-system rule was developed, where the city of Hong Kong could keep its Western style of government without Chinese interference so as long as it declared itself a part of China. The Hong Kong people felt the system was abridged when the unanimous vote by the Standing Committee of the National People's Congress forced the contenders for the Hong Kong 2017 elections to be solely nominated by the Chinese who favored pro-Beijing loyalists. In light of the decision, activist groups Occupy Central with Love and Peace, Hong Kong Federation of Students, and Pan-democracy camp declared continuous protests until full democracy was restored.
"I was born in Hong Kong, when it was under British rule. I have followed this
movement closely because it was my home at one time," says Kai Chan, a Digital System Design teacher. "I believe if this protest doesn't gain momentum soon, China may enforce a one country, one policy rule, meaning China may take back total control of Hong Kong. No special privileges for HK citizens."
In agreement with Mr. Chan, Wilson Liu'16 claims that if the protests fail, Hong Kong residents can lose all of their rights.
According to Forbes, the protests have cost the city of Hong Kong $40 million in damages and economic shutdown. Having set up camps over central areas of Hong Kong, peaceful protesters engaged in an "Umbrella Revolution". Schools were suspended, shops and banks were closed, taxi service was stopped. While headlines in newspapers, magazines, and news broadcasts overwhelmed the world with ongoing updates of the situation, China took heavy action by censoring the internet and restricting the use of Instagram, a popular photo-sharing platform.
"I think it is important for people to have a say in the course of [their] nation." comments Adham Abdelhameed '15. "Fighting for democracy brings people together and promotes greater unity."
"People don't appreciate the value of freed
om, until it's gone," adds Mr. Chan."I never forgot an incident that happened when I visited China in the 60's. I saw a man bounded by his hands and feet, wearing a red card-board sign around his neck, being paraded around the streets because this man was found guilty of anti-government."
In a recent update by The Wall Street Journal (WSJ), three men were arrested in Mong Kok on November 5th, 2014 for "criminal damage" and "obstructing police officers executing their duty." The WSJ also reported that a two-day leaders' summit held by Chinese President Xi Jinping will begin on Monday, November 10th, where President Obama is expected to attend.

subset: commoncrawl


text:
Ciara Shines While Singing National Anthem At College Football Championship Game
Ciara absolutely crushed it during her national anthem performance at the 2016 College Football Playoff national championship game Jan 11. The Grammy Award winner sang before the biggest game in college football between Alabama and Clemson and didn't disappoint.
Get it girl! Ciara, 30, belted out the national anthem at the College Football Playoffs national championship football game, held in Glendale, AZ Jan. 11. Her musical 'Goodies' were heard by football lovers everywhere, as the singer started the night off right. Since she's engaged to Seattle Seahawks quartnerback Russell Wilson, we're figuring she's knows a thing or two about being comfortable at championship football games!
Yes Ciara, yes! The "1, 2 Step" singer wowed us with her vocal chops to work at the championship for the ages. Ciara proved that she's still at the top of her game she belted out the famous song. She looked stunning in a white sequined gown with a dramatic cape as she gave a super powerful performance of the Star Spangled Banner that still stayed true enough that everyone in the stands was able to sing along.
Singing the national anthem at the game was not the first time Ciara performed in Arizona this week. The R&B artist also help kick off a concert series held in downtown Phoenix that AT&T put on in honor of the championship. As part of the playoff festivities, the AT&T Playoff Playlist Live! concert series started a few days before the teams took the field, with The Band Perry, Walk The Moon, David Nail and more as some of the headlining performers.
Cici, who was part of the Jan. 9 lineup before the big game, performed a number of her hits including "Lose Control," "Oh" and "1, 2 Step." It was almost impossible not to dance along! Clearly, the singer can still wow an audience as she dazzled in both performances. Now let's get ready for some football!
HollywoodLifers, what did you think of the performance, did Ciara kill it? Give us your musical opinions below!


text:
Title: Only By His Touch
Author: Bree Kraemer
Genre: Contemporary Romance.
Recommend it: YES
Recommend it to Who: Anyone in need of a charming, witty and passion-filled romance novel.
You can get your Kindle version from Amazon.
Note: I got a free copy of this book from the author in exchange for my very honest review.
Several years after a tragic event, Samantha still finds herself unable to get close to others. The slightest bump into someone makes her cringe and she avoids handshakes as much as possible. She can't even touch her close friends and family. It seems she will never be able to overcome that terrible, life-changing day.
Until one day, she sees a man that may change everything for her. This man seems so familiar and without even thinking it through she has an undeniable urge to touch him. Where does she know him from?
Will this handsome stranger be able to help her to become the person she was before?
This is a first full novel written by Bree Kraemer. I was reading an unedited version so I'll not point out errors and the like but instead I'll talk about the controversy behind such a premise, the characters, the overall plot and how it all made me feel.
The author, Bree Kraemer brings us a very inspiring, funny and emotional story. It has wit, it has charm and the characters were very likeable and relatable. Just everyday people who experience things that anyone one of us could go through. I read it with a stupid grin on my face. Okay, fine, some parts made me sad and curse out loud.
I particularly loved it because of the main female lead, Samantha. After a very horrific and life-altering incident, she was willing to give living a shot. She didn't let fear and 'what-ifs' dictate her life anymore. Sure, it took years for her to let anyone close but when she did, I truly felt inspired. Imagine a world where you avoid all human contact…you're not a germaphobe but it's still just as hard. Crowds make you nervous and elevators are a nightmare. How would you live?
As a female and being close to Samantha's age, I felt really attached to her and felt her pain. The PTSD she had was believable and it touched me how her life was affected. But like most people who are hurting, she masked her pain with sarcasm, wit and jokes. I loved that because that's how I usually live my life. It's a better alternative to being moppy and wanting everyone to feel sorry for you…all the time.
I don't know how long it takes someone to get over what happened to her so I can't really comment on it much. But I can say the fact that she took a leap of faith and decided to not be afraid anymore really sat well with me.
Then, in walks Ethan. A man who signed up for the army straight out of high school. He has his own tragic story but like Samantha, he picked himself up and made something of his life. As someone who was in the army, Ethan came off as a 'perfect' gentleman. Notice how I write perfect? Yeah, well, that's because perfection is so hard to achieve. He was caring, loving, funny and yep, attractive as heck.
"Even blurry, he was handsome. Well, handsome really wasn't the right word. He wasn't hollywood handsome. He was real-life handsome."– Only By His Touch
I laughed at this part. It made me happy. He came into her life and for the first time in a long time, Samantha felt alive again. He never rushed her to accept him or did anything to make her feel uncomfortable. He just wanted to spend time with her. It was nice to read.
"You can be gentle, rough or any other way there is, just as long as you're with me."– Ethan
I enjoyed how their story was written, the feelings were not forced and rushed. You could clearly see that it wasn't love at first sight but a love that grew over a period of time and got stronger as they grew together. There conversations were natural and they both had great sense of humour. I love funny characters.
The other characters were likeable too. Well except one bitch who deserves a year behind bars or something. It was a welcome plot point that made the story even more real.
I'm a sucker for romance and when beautiful words are used I can't help the feelings that start up in me. Come on, we love the notebook for a reason :). Every great relationship has bumps along the way and when you work through them, that's when you become even stronger.
I loved the quote below a lot, I just had to share it. See if you can tell why…
"Say that you know that I want to try this too. Say that you'll understand if we have to take it slow. Hell, say that you want me so much it might kill you, but please don't say that you need to wait or walk away."– Only By His Touch
There was enough drama and conflict but not too much that you cringe and think you're watching a spanish telenovela. They say too much of anything is bad…well except books maybe and pineapples :D.
I've tagged the story as Erotic so I have to talk about the sex, right? Now again, I'm out of my element here -not talking about sex, I read Erotica, talking about sex has to be my element- but I mean just how sex would eventually happen for someone so traumatised. I don't know anyone who's ever gone through such and ordeal. So, I'll talk about how it made me feel.
As with everything in the book, even these scenes where written so well. It didn't come off as dirty or cheap. It didn't make me want to wash my brain with soap and bleach. It was beautiful and it was hot. Okay, fine 'hot' is an understatement. It was panty-melting-lip-bitting-ice-cube-requiring sizzling hot. Ethan was one mean 'cat-lover' *wink *wink.
I should probably end there before I go full "Perve Mode".
I will say this, however, even when she (the author) was hinting at sex, she made it all sound beautiful and made me happy.
"I'm asking you to make me forget. But more than that, I'm asking you to make me remember. Help me remember what it feels like to touch and be touched. Help remember why I should take chances. But most of all, help me remember that love always wins over fear."– Only By His Touch.
Now I confess. At first I was a bit skeptical…I thought it was going to be another wounded-heroine-meets-hot-eye-candy-and-he-heals-her-with-his-magic-penis. You know the stories I'm talking about. You've probably read enough. You roll your eyes so much that you develop a headache. This however wasn't like that…at all.
As a first novel, it was well executed.
That's all for this review.
Follow me on twitter Dee@The perks


text:
Radically simplify and accelerate service creation, deployment, and support with our proven and integrated ITSM platform.
Dramatically reduce requests and increase user satisfaction by empowering users to solve their own issues with our innovative self-help solution.
Service Apps
All Products
IT Service Management
IT Asset Management
IT Financial Management
Change & Release Management
Self-Service Portals
Intelligent Knowledge Management
Responsive Applications
Service Asset & Configuration Management (CMDB)
Project Management
ITIL Processes
Request Management
Learn more about how EasyVista partners with your company to deliver on ITSM goals.
The Formula for Success
Customer Success Stories
We're committed to providing resources that help you address all of your ITSM software needs.
Case Studies
Product Tours
Data Sheets
The single most important indicator of a successful IT self-service portal boils down to this: Do business consumers use it? Self-service benefits such as lower IT costs, reduced workloads, and 24/7 support can't be realized if portals are not being utilized. Despite this fact, self-service deployments are rarely designed to appeal to end users—and even fewer are built with the goal of providing value to the business consumer.
Get best practices for designing IT self-service portals that will delight end users and keep them coming back for more with Gartner's Report: Design IT Self-Service for the Business Consumer.
In this report, Gartner shares how enterprise IT organizations can leverage proven techniques used by consumer service providers to increase IT self-service user adoption and satisfaction levels, offering tips on:
Please complete the form to download Gartner's report.
Gartner, Design IT Self-Service for the Business Consumer, Chris Matchett, 04 October 2017
GARTNER is a registered trademark and service mark of Gartner, Inc. and/or its affiliates in the U.S. and internationally, and is used herein with permission. All rights reserved.


text:
Perdue soybean plant in Lancaster County finds market
Last September, Perdue AgriBusiness opened Pennsylvania's first large-scale soybean processing facility in Conoy Township, Lancaster County.
The plant cost over $60 million to build, with state grants covering $8.75 million of the tab.
In building the plant, Perdue promised to purchase locally grown soybeans year-round from local farmers, and to sell soymeal, refined soy oil and soy hulls back to farmers to be used in animal feed.
The Salisbury, Maryland-based company also promised to comply with environmental regulations enforced by the federal government and by the state Department of Environmental Protection. Leading up to its construction, the plant was met with environmental concerns from both the state and the public, particularly surrounding its use of the chemical hexane.
Some of the compounds within hexane are considered precursors to smog, and one compound is classified as a hazardous air pollutant.
DEP issued two minor violations to Perdue so far, one related to storage tanks and one for air monitoring, according to John Repetz, community relations coordinator for the DEP Southcentral Regional Office. Perdue submits monthly, quarterly and semi-annual monitoring reports to DEP, keeping the lines of communication open.
A year after its opening, the plant has added over three dozen skilled manufacturing jobs and is finding a role in the region's agricultural economy.
The plant buys soybeans from farmers and processes the beans to produce soymeal, soy hulls and soy oil, which is refined into vegetable oil. The farmers then buy those products to feed their animals.
It wasn't always that simple.
How it works
The new Perdue AgriBusiness facility is a solvent extraction plant, meaning it uses hexane, a byproduct of petroleum, to extract oil — in this case, from soybeans.
Three products are created from the extraction process, according to Kevin Woleab, the plant's superintendent: soy oil, soy hulls and soymeal. Each product has value, and each product has some power in influencing the state's economy.
First, soy oil: it is extracted from the soybean at the plant and starts as a non-food grade product. A portion is then sold as-is to fuel companies for use in making biodiesel. Perdue also refines a portion of the soy oil in Salisbury, Maryland, where it becomes edible vegetable oil to be sold to farmers for use in feed mixes, as well as to snack food companies to be used in food production. Some of those companies are located in the same midstate region where the soybeans are grown.
Soy hulls are the high-fiber outer covering of the soybean, much like a peanut shell, according to Joe Forsthoffer, director of corporate communications for Perdue. The hulls are used in feed mixes for animals that can process fiber well, like dairy cattle.
Finally, the third and most valuable product, soymeal, is sold back to farmers to be used in animal feed. A typical feed mix includes soymeal, corn and vegetable oil. Manure produced by the animals, meanwhile, is used to fertilize the next crop of soybeans.
Before soymeal became available to farmers last year as a result of the new plant, farmers relied on dry distillers grain, mostly to feed their livestock, which they purchased from corn distillers that were often located farther away than Perdue's new plant.
In addition to reduced transportation costs, soymeal also is farmers' preferred feed ingredient: it's a higher-quality product than dry distillers grain.
"Distillers grain is like the iceberg lettuce of feed," said Jay Stauffer, a Lancaster County farmer. "Soymeal is like the arugula or mixed baby greens of feed."
In years past, local soybean farmers transported their bushels to either small-scale operations or to ports in New York and Maryland for export to foreign countries. Transportation wasn't cheap, and it was difficult to schedule deliveries due to limited receiving times at the ports. The logistics had to be determined in advance – costing farmers time during harvesting season.
Now, farmers can deliver to Perdue's grain elevator in Lancaster County, 24 hours a day, seven days a week. The elevator adjoins the plant and acts as storage space for the soybeans until they are moved to the plant to be processed.
With an elevator capacity of 1.5 million bushels, Perdue was able to purchase $140 million worth of soybeans last year, according to Gary Cordier, senior vice president of domestic grain for Perdue.
The large-scale buying power has had a positive effect on farmers like Jay Stauffer, a grain, swine and heifer farmer in West Hempfield Township, Lancaster County. He also farms land in York County.
"We like Perdue, and we're glad they're here," he said.
Just three months ago Stauffer added a driver and an extra tractor trailer to support the growing demand for soybeans from Perdue. Perdue temporarily leased land from Stauffer to store even more bushels after reaching capacity last year.
"Farmers have to trust us," said Joe Forsthoffer, director of corporate communications for Perdue. "And we never turn a farmer away."
In some cases, farmers choose to wait to sell their soybeans until prices are good, storing them in their own facilities until then.
"Unlike milk, farmers can store soybeans and wait out when they potentially sell them. But they need to pay their bills, so they can't wait forever," said Mark O'Neill, communications director for the Pennsylvania Farm Bureau, based in Camp Hill.
The price of soybeans reached a historic high in 2014 on the Chicago Board of Trade at $10.50 per bushel, which is equal to 60 pounds. The demand from foreign countries was high then, likely influenced by drought overseas and the relatively high value of the American dollar, according to O'Neill.
Prices have been on the downturn for the last year due to tariffs put in place by China. Even before the tariffs set in, the price began to drop, falling as low as $8 a bushel. Though Perdue and other buyers are largely unaffected by the price decrease, soybean producers have taken a hit.
"Growers are hoping it's a short-term drop," O'Neill said. "The income difference even from $10 to $8 is a major shock to the system."
Because of the fluctuating market price, which is out of their control, farmers will often go to great lengths to save money on the things they can control, like transportation costs.
Stauffer isn't sure exactly how much he saved by purchasing soymeal and selling soybeans locally to Perdue instead of shipping directly to the ports, but he is sure it has saved him some.
"Even if I could save just $300, I would do that. Everything counts," he said.


text:
During 2016, we've focused on providing you with more answers to your flooring and design questions through the Classique Floors + Tile redesigned website and also through the articles we share with you here on the Classique Floors + Tile Blog. In fact, we've put together this recap of blog articles published organized by product category to better help you as you make decisions about the kinds of products to purchase for your floors and home.
Getting Started: Flooring Food for Thought
You're excited about selecting the perfect floor for your dream addition or long-planned home remodel. And then you realize you don't know where to start to make that dream become reality. No worries! Here is what to consider to get you organized and help you pick the perfect flooring, including if your concerned about asthma or allergies, sustainability or need design guidance.
>> Read 5 Important Considerations to Help You Pick the Perfect Flooring For Your Home
>> Read Allergies? Asthma? Create your healthy home with smart flooring choices
>> Read Convenient Truths: Green flooring is less expensive and more accessible
>> Read Create a Kitchen Design Board (Choose Kitchen Tile, Flooring, Cabinets, Countertops, Paint, etc.)
>> Read Kitchen & Bath Remodeling: an Interview with Eric Eaton
Focus on Tile Floors and Walls
Are you mad for tile and ready to make decisions about what to buy? Here are links to the resources we developed with answers to questions about tile, including why tile is so eco-friendly. You'll also find images and loads of design inspiration, and detailed information about what you can expect when you decide to buy tile from Classique.
>> Read 5 Questions to Ask When Selecting Tile for Your Home
>> Read What Makes Tile a Perfect Eco-Friendly Flooring Solution?
>> Read An Interview with John Zoubek, American Olean and Marazzi Tile
>> Read Make Statements with Tile: an Interview with Jessica Milano
>> Read Designing with Large Size Tile: an Interview with Amy Bright, sTile
>> Read Discover Endless Tile Design Possibilities: an Interview with Pratt & Larson's Holly Menashe
>> Read 8 Reasons to Buy Tile from Classique Floors + Tile and get a sneak peak of our showroom!
Focus on Carpet Questions
Infinitely versatile, carpet is a great choice for many of the rooms in your home. Here are articles providing you with perspective on carpet, the styles available, how carpet padding fits in and how to select the right carpet for your home.
>> Read Questions to Ask When Choosing New Carpet for Your Floors
>> Read Quality carpet, how do you choose?
>> Read All About Carpet Styles: Frieze, Berber, Loop, Patterned and More
>> Read Five important carpet buying tips
>> Read The Ultimate Guide to Carpet Padding at Classique Floors
Focus on Wood Questions
Good looking, long lasting and a great investment in your home's overall value, hardwood flooring is the perfect marriage of practicality and elegance when it comes to home improvement. In this section, you'll find resources answering questions about the types of wood flooring available (including engineered hardwood flooring) and how to select the right one for your home.
>> Read 8 Questions to Help You Select Wood Flooring
>> Read Engineered hardwood flooring makes your life easy!
>> Read For High Quality Wood Flooring, Select Mirage Hardwood Floors at Classique Floors + Tile
Focus on Wood Plastic Composite (WPC) and Luxury Vinyl Tile (LVT)
Love the look of wood, but worried about how it will wear in your busy household or in spaces where shoes track in mud and rain? WPC or LVT may be just the solution for you. Learn more from these resources:
>> Read COREtec Flooring, the Ideal Waterproof Solution for Your Floors
>> Read LVT Flooring: Nine Things We Love About Luxury Vinyl Tile
>> Read Luxury vinyl tile: Portland homeowners love this new flooring choice
About Classique Floors + Tile
In addition to providing answers to your flooring and design questions via the website, we also have a terrific team of design professionals ready to help you when you visit Classique Floors + Tile. Three of them were profiled in 2016:
>> Read Meet Annette Leoni-Idler, Classique Floors + Tile Showroom Manager
>> Read Meet Carly Hunt, Classique Floors + Tile Project Consultant
Stay tuned for additional introductions in 2017.
Here's perspective on a really wonderful Portland neighbor: Community Building in Portland OR with Habitat for Humanity
Ready to shop Classique Floors + Tile for tile?
We invite you to visit our Portland, Oregon showroom to explore what's possible with tile. Or schedule an in-home project assessment. Your Classique project consultant will guide you through everything from initial estimate to product selection to final installation.
You'll be delighted. We promise.
Thanks for reading,