The content below is taken from the original (PowerShell Problem Solver: Finding Needles in the Active Directory Haystack), to continue reading please visit the site. Remember to respect the Author & Copyright.

Recently, a follower sent me an email with a problem that he was trying to solve with Active Directory (AD) and PowerShell. At first, I was a little puzzled by what he was trying to do. We spent some time going back and forth on possible solutions. During the process, I realized his situation presented a great teachable opportunity. Let’s see what we can learn about PowerShell.

The initial problem was to find all AD computer accounts, where part of the name was found in a list of names. The initial code, which was not working, looked something like this:

$Filter = (Get-Content names.txt)
 Get-AdComputer  -Filter * | where-object{"*"+$_.name+"*" -match $Filter} | select name

It did not have errors but it also did not have results. Let me show you what is in the names.txt file.

Getting the List of Names (Image Credit: Jeff Hicks)

We needed to find computer accounts that had usernames as part of the name. I am using a small list but it could easily be hundreds of names. My friend knew there were accounts that should be found because he could find them on an individual basis.

 Finding a Matching Computer Account (Image Credit: Jeff Hicks)

Naturally, he was looking for a way to scale out this process. One approach we considered, was using the -Contains operator. He was really checking to see if the computer name belonged to a list.

Get-AdComputer  -Filter * | where-object{ $filter -contains $_.name} | select name

This does not quite work. If by chance $Filter contained the complete name, then this approach would work.

Testing with Full Names (Image Credit: Jeff Hicks)

This was not the case. The only thing he knew was that the username might be a part of the computer name. We needed to go back to the drawing board.

Conceptually, I was beginning to realize what he needed. Talking through the process was helpful. You may also find it helpful to simply write it as a narrative.

“Get the computer names from AD and then look at each name. If the computer name property matches a value from the list of names, then get the computer name and distinguished name properties.”

At this point, it also became clear that trying to write this as a one-line solution was not practical. It could probably be done but it would be overly complicated. This is a trap many PowerShell beginners fall into, thinking they need to write one-line solutions. This not true. Sometimes, it makes much more sense to break the process down into several steps.

Based on my narrative, I knew the first step was to get all the computer accounts from AD.

$ad = Get-ADComputer -filter *

This turned out to be 96 items in my test domain. Next, get the list of usernames from the text file.

$names = Get-content .\names.txt

The main comparison has to be done on each computer account, one at a time. To make it easy to follow, I used the ForEach enumerator.

foreach ($name in $names) {
    $ad | Where {$_.name -match $name} | Select name,distinguishedname
 }

The code loops through each name. It then pipes $ad to Where-Object to see if the name matches.

Filtering Computer Names (Image Credit: Jeff Hicks)

You can see that it works. You may be wondering why I did not put the Select-Object expression after ForEach. ForEach does not write anything to the pipeline but I can do this on the inside.

There is also one other minor nit. If you see the output, you will notice there is a valid server name in the list, time-server2. It gets caught on the name tim. This is because of the regular expression, -match operator matched.

The solution is to use a more restrictive pattern. In fact, I should also try to limit the number of computer accounts to test as well. I know that any computer account in my domain that starts with CHI- is okay. I may try filtering Get-ADComputer like this:

Invalid Filtering Operator (Image Credit: Jeff Hicks)

This almost works. You cannot use -Match as a filtering operator with Get-ADComputer. I will do the next best thing and use -like.

$ad = Get-ADComputer -filter {Name -notlike "CHI-*"}

Now, I get 44 computer names. Here is my revised ForEach loop with a better regular expression pattern and using the Where() method for better performance.

foreach ($name in $names) {
    ($ad).Where({$_.name -match "$name$"}) | Select name,distinguishedname
}

There are certainly other ways to solve this problem but I hope you will pay attention to the process and principals I used.

The post PowerShell Problem Solver: Finding Needles in the Active Directory Haystack appeared first on Petri.

The content below is taken from the original (IBM wheels out bleedin’ big 15TB tape drive), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (Manage your business needs with new enhancements in Azure Autoscale), to continue reading please visit the site. Remember to respect the Author & Copyright.

Automatically scaling out or scaling in applications to handle the demands of your business is an essential element of the cloud strategy. Azure’s Autoscale service empowers you to automatically scale your compute and App Service workloads based on user-defined rules regarding metric conditions, time/date schedules, or both. Azure Autoscale is available for Classic Cloud Services, Virtual Machine Scale Sets (VMSS) and App Services. Today we are excited to announce a host of improvements to Autoscale, including faster auto scaling, simplified configuration, the ability to scale by a custom metric using Application Insights, and more troubleshooting information available in the Activity Log.

Faster Autoscale

Classic Cloud Services: The Classic Virtual Machine infrastructure that powers Classic Cloud Services now supports more reliable, host-level metrics via the Azure Monitor metric pipeline. Because of this, an Autoscale setting can now be set to have as low as a five-minute time window to activate (previously we recommended a time window of no less than 30 minutes). With this, you can now do faster and more reliable auto scaling. If you have a Classic Cloud Service Autoscale setting where you wish to take advantage of the improved scaling, please update it with a shorter time window (as low as five minutes).

VMSS and App Services: The Autoscale engine for VMSS and App Services can also now trigger scale actions faster. The new engine is tuned to check for your metric based rules every minute, thereby enabling the ability to scale your instances as early as 1 minute after a metric value crosses the threshold set in an Autoscale setting. To take advantage of the faster Autoscale, please update your existing autoscale setting. All new Autoscale settings created or updated on VMSS or App Services after May 10th will automatically use the new engine.

Simplified management experience in the portal

Based on your feedback, we made it easier to discover and manage Autoscale settings in the portal. Autoscale settings can now be accessed directly from within the Azure Monitor blade, use a completely re-vamped configuration blade, and enable you to easily see the full template in JSON or scale action history for that setting. Learn more about how to get started with Autoscale today.

Figure 1. the new tab within Azure Monitor for accessing and managing Autoscale settings.	Figure 2. the simplified Autoscale blade with options to view scale action history, view the JSON object and edit notifications.

Autoscale using custom metrics

One of our top customer asks was to be able to Autoscale based on a custom, user-defined metric, and we’ve now enabled it using Application Insights. This new capability is available now and enables you to scale Classic Cloud Service, VMSS or App Service workloads by any Azure Monitor based metric or custom and application metrics collected by Application Insights, Azure’s application performance management service. Here is a sample of an Autoscale setting that allows you to scale your Web API app based on a custom metric ingested to Application Insights. This ability to Autoscale via Application Insights based metrics is now available in public preview, please try this out and share your feedback.

Figure 3. the ability to select Application Insights as a source of metrics and the ability to select a standard or user-defined metric by which scaling will occur.

Improved Autoscale troubleshooting

The Autoscale engine logs an event in Activity Log every time it triggers a scale action, however, the target resource that is being scaled out or in can take the time to complete the scale action. It is important to know when the scale action completes or reports as failed so that you can take automated actions on the resource. To support this, the Autoscale engine now generates a scale action result event when the underlying target service completes the action or reports it as failed. This scale result event is also logged in the Activity Log and includes valuable information about why your Autoscale event failed. We’ve also introduced a new Autoscale Activity Log category so that you can easily filter to view only Autoscale-related events. You can leverage the new Activity Log Alerts to receive notifications or take automated actions via webhooks and Azure Automation, Logic Apps or Functions. This feature is now enabled for Cloud Services, VMSS and App Services.

Figure 4. A view of Activity Logs filtered by Autoscale events, listing the Autoscale trigger action and result event.

Wrapping Up

These new capabilities in Azure Autoscale enable you to efficiently leverage the compute power of Azure to scale your applications to best suit your growing business needs. We are eager to hear your feedback to inform our future work on Autoscale. Please try these new features and let us know what you think. Also be sure you’re getting the most out of this feature by checking out our Autoscale best practices, and most common autoscale patterns.

The content below is taken from the original (5 Facts Everyone Should Know about Containers), to continue reading please visit the site. Remember to respect the Author & Copyright.

read more

The content below is taken from the original (US Coast Guard: We’re rather chuffed with our new Boeing spy drone), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (Azure CLI 2.0: new commands, features; available now in Azure Cloud Shell), to continue reading please visit the site. Remember to respect the Author & Copyright.

az interactive

# login to your Azure account from the Azure CLI
az login  

# select the Azure subscription you want to use in your account
az account set –-subscription “My Demos”  

# create a new resource group in your subscription (or skip this step if
# using an existing resource group)
az group create –-location westus2 –-name MyResourceGroup

# create a new server in Azure MySQL database within the selected resource
# group 
az mysql server create –-name MySQLServer –-resource-group MyResourceGroup `
--location westus2 –-user AdminUser –-password AdminPassword

# create a new firewall rule for your MySQL database to allow client
# connections
az mysql server firewall-rule create –-name MyFirewallRule –-server `
MySQLServer –-resource-group MyResourceGroup –-start-ip-address 0.0.0.0 `
--end-ip-address 255.255.255.255

# create new app service plan in the selected resource group
az appservice plan create –-name MyAppSvcPlan –-resource-group `
MyResourceGroup –-sku FREE

# create a new web app in the above app service plan, set PHP runtime version
# and configure for local Git deployment (all in one simple command)
az webapp create -g MyResourceGroup -n MyWebApp --plan MyAppSvcPlan --runtime "php|7.0" --deployment-local-git

# set the deployment user for the web app to deploy it from your local
# machine using Git
az webapp deployment user set –-user-name LocalGitUser –-password `
LocalUserPassword

# update the web app config settings to use MySQL database
az webapp config appsettings update –-name MyWebApp –-resource-group `
MyResourceGroup –-settings DB_HOST=MySQLServer.windows.net `
DB_DATABASE=”sampledb” DB_USERNAME=”dbuser@MySQLServer” `
DB_PASSWORD=”dbuser_password”

# update app-key with generated application key for your web app on Azure
az webapp config appsettings update –-name MyWebApp –-resource-group `
MyResourceGroup –-settings APP_KEY=”generated app key” APP_DEBUG=”true”

az functionapp create -g MyFunctionRG1 -n myfunction -s myfuncstg -c westus2 –u http://bit.ly/2q4UZuJ

The content below is taken from the original (Management Pack for Microsoft Azure Stack now available), to continue reading please visit the site. Remember to respect the Author & Copyright.

With this blog post we announce the availability of the technical preview of the Microsoft Azure Stack Management Pack for System Center Operations Manager.

Microsoft System Center is a powerful management tool for the datacenter. Microsoft Azure Stack is a new hybrid cloud platform that allows you to run Microsoft Azure services in your datacenter. Azure Stack integrated systems will be a part of the larger assets customers have in their datacenters, so it is vital that there is an integration that facilitates aggregate management via System Center for Azure Stack.

Download the management pack!

This management pack enables System Center Operations Manager 2012 R2 & 2016 to monitor Azure Stack.  In addition to alert management, Operations Manager expands Azure Stack with capabilities like sending notifications via different channels or scheduling maintenance windows during an update run. Once alerts are received in the Operations Manager, existing connections within the Operations Manager to other products, such as Service Manager, can be leveraged. For example, this product can be leveraged to create a service ticket. 

This management pack allows you to integrate Microsoft Azure Stack with your existing IT Lifecyle by leveraging already existing processes and workflows. The Health dashboard allows to view and drill into the health of multiple deployments of Azure Stack including multiple Azure Stack Regions, once available.

For customers not using Microsoft System Center Operations Manager, we also released a Nagios monitoring plugin with similar capabilities in partnership with Cloudbase. This plugin is written in python and leverages Azure Stack Health Resource Rest API. The same rest API is used by Azure Stack’s own Portal, PowerShell, and of course the Azure Stack Management Pack. Please provide feedback by using the Azure Stack Forum. If you have a feature request that we should consider please use Azure Stack User Voice.

Additional resources

• Azure Stack Management Pack for System Center Operations Manager
• Azure Stack Plugin for Nagios 
• Azure Stack Tools
• Microsoft System Center  

The content below is taken from the original (Compute Engine machine types with up to 64 vCPUs now ready for your production workloads), to continue reading please visit the site. Remember to respect the Author & Copyright.

By Scott Van Woudenberg, Product Manager, Google Compute Engine

Today, we’re happy to announce general availability for our largest virtual machine shapes, including both predefined and custom machine types, with up to 64 virtual CPUs and 416 GB of memory.

64 vCPU machine types are available on our Haswell, Broadwell and Skylake (currently in Alpha) generation Intel processor host machines.

Tim Kelton, co-founder and Cloud Architect of Descartes Labs, an early adopter of our 64 vCPU machine types, had this to say:

"Recently we used the 64 vCPU instances during the building of both our global composite imagery layers and GeoVisual Search. In both cases, our parallel processing jobs needed tens of thousands of CPU hours to complete the task. The new 64 vCPU instances allow us to work across more satellite imagery scenes simultaneously on a single instance, dramatically speeding up our total processing times."

The new 64 core machines are available for use today. If you’re new to GCP and want to give these larger virtual machines a try, it’s easy to get started with our $300 credit for 12 months.

The content below is taken from the original (Business chat review: Slack vs. Teams vs. HipChat vs. Yammer), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (Windows on the rise at GCP), to continue reading please visit the site. Remember to respect the Author & Copyright.

By Chris Sells, Product Manager

It’s been a little over three months since we made our no-charge VM migration tool available for GCP in the Google Cloud Console, and customers have jumped at the chance to move their enterprise workloads to Google Cloud. While customers are moving applications using a variety of source operating systems to Google Cloud, we’ve been especially excited to see that almost half of the VM migrations to Google Cloud via this new service have been of Microsoft Windows workloads.

Why is this significant to you? Because our goal to make Google Cloud the best place to run any application — from Windows workloads to new cloud native applications. We believe that the significant number of Windows applications migrating to Google Cloud through this new service is indicative of strong demand to give enterprise Windows applications the agility, scale and security advantages of Google Cloud.

“We are leveraging Google Cloud to deliver the experiences our customers demand, and we want to make sure that all our workloads can take advantage of Google Cloud’s unique infrastructure and services. Using the free Google Cloud migration tools, we’ve been able to easily move our Windows servers to Google Cloud with near-zero downtime.” — Rob Wilson, CTO at Smyths Toys

We’re happy to see customers take advantage of our first class support for Windows, SQL Server and both .NET and .NET Core on GCP. We’ve made sure that those applications are well-supported by providing support for Windows Server 2016 within weeks of it reaching GA, by adding support for SQL Server Web, Standard and Enterprise editions (including support for High Availability), by integrating Visual Studio and PowerShell, by making all of Google’s APIs available via NuGet and by joining the .NET Foundation’s Technical Steering Committee. Further, with Stackdriver Logging, Error Reporting and Trace support for Windows and .NET; developers and administrators have the support they need to build, deploy and manage their applications. Finally, with the recent announcement of .NET Core support in all of our libraries and tooling, as well as in our App Engine and Container Engine products, you’re covered into the future as well.

Internally, we’ve seen other signs of more Windows and .NET workloads running on GCP, including a 57% increase in Windows CPU usage in the second half of 2016. Further, we know that sometimes you need help to take advantage of the full capabilities of GCP, which is why we announced the Windows Partner Program. These top-notch systems integrators will help you to not just “lift & shift,” but rather to “move & improve,” with cutting-edge capabilities such as big data processing, data analytics, machine learning and container management.

Learn more about Windows, SQL Server and .NET on GCP; and don’t hesitate to reach out with questions and suggestions. We’ve had lots of folks make the switch already, we’d love you to join them. Our migration service is offered at no charge and you get $300 of GCP credits when you sign up so you can migrate a few servers to see how easy it is to run your windows apps in GCP. Click here to get started.

The content below is taken from the original (Shazam: Why cloud GPUs finally make sense), to continue reading please visit the site. Remember to respect the Author & Copyright.

By Ben Belchak, Head of Site Reliability Engineering, Shazam

At Shazam, we’ve been heavy users of graphics processing units (GPUs) for our recognition services since 2012, starting with the NVIDIA TESLA M2090 and working our way up to the K80 today. We’ve traditionally used bare metal servers because GPUs in the cloud have not been available, and when they have, they were far too expensive and not performant enough for our needs. Only recently have the economics of GPUs in the cloud really made sense for our business. This is what kicked off our journey to Google Cloud Platform (GCP).

For certain tasks, GPUs are a cost-effective and high-performance alternative to traditional CPUs. They work great with Shazam’s core music recognition workload, in which we match snippets of user-recorded audio fingerprints against our catalog of over 40 million songs. We do that by taking the audio signatures of each and every song, compiling them into a custom database format and loading them into GPU memory. Whenever a user Shazams a song, our algorithm uses GPUs to search that database until it finds a match. This happens successfully over 20 million times per day.

To meet that demand, we’ve been maintaining a fleet of GPUs on dedicated bare metal servers that we lease from a managed services provider. Because of the time it takes to source and provision a new physical server, we provision enough to meet peak demand and then run that capacity 24/7, 365 days a year. We kept costs under control by improving our algorithms and by taking advantage of ever-evolving GPU architectures and the performance improvements they brought. About six months ago, though, we began experimenting with GPUs running on Compute Engine. Thanks to the speed with which we can dial new instances up and down, we maintain GPU infrastructure to handle average use instead of the full capacity for our maximum peak load. Thus far, we’ve migrated about one-third of our infrastructure into Google Cloud.

In order to efficiently search our massive catalog of music, we maintain multiple levels of GPU server clusters that we call "tiers." A first tier searches against a database of the most popular songs’ audio signatures, while subsequent tiers search longer samples against progressively more and more obscure music databases. In this way, Shazam identifies, say, "Thinking Out Loud" by Ed Sheeran in a single pass from a short sample, but might need several passes and a much longer sample to identify a 1950s recording of a Lithuanian polka group (being able to match really obscure music in addition to popular music is what makes using Shazam such a magical experience for our users).

Increasing the hit rate on the first line of servers depends on keeping the index files up to date with the latest popular music. That’s hard to do given how quickly music falls in and out of favor. Some surges in traffic we can plan and pre-scale for, such as the Super Bowl, the Grammy’s, or even our first branded game show, "BEAT SHAZAM." Other surges we cannot predict — say, a local radio station in a large market reviving an old R&B hit, or when a track that was never popular is suddenly featured in a TV advertisement. And that’s not counting new music, which we add to our catalog every day through submissions from labels as well as by in-house music experts who are constantly searching for new music.

Of course, running on bare metal servers, we also need to provision extra capacity for the inevitable failure scenarios we all experience when operating services at scale. One of the amazing benefits of running in Google is that we can now replace a failed node in just minutes with a brand new one “off the shelf” instead of keeping a pool of nodes around just waiting for failures. In our managed service provider, we had to provision GPUs in groups of four cards per machine, with two dies per card. That meant that we could lose up to eight shards of our database when a node failed. Now, in Google, we provision one VM per shard, which localizes the impact of a node failure to a single shard instead of eight.

An unexpected benefit of using Google Cloud GPUs has been to increase how often we recalculate and update our audio signature database, which is actually quite computationally intense. On dedicated infrastructure, we update the index of popular songs daily. On Google Cloud, we can recompile the index and reimage the GPU instance in well under an hour, so the index files are always up-to-date.

This flexibility allows us to begin considering dynamic cluster configurations. For instance, because of the way our algorithm works, it’s much easier for us to identify songs that were Shazamed in a car, which is a relatively quiet environment, than it is to identify songs Shazamed in a restaurant, where talking and clanging obscure the song’s audio signature. With the flexibility that cloud-based GPUs afford us, we have many more options available to us for configuring our tiers to match the specific demands that our users throw at us at different times of day. For example, we may be able to reconfigure our clusters according to time of day — morning drive time, vs. happy hour at the bar.

It’s exciting to think about the possibilities that using GPUs in Google Cloud opens up, and we look forward to working with Google Cloud as it adds new GPU offerings to its lineup.

You can find out more details about our move to Google Cloud Platform here: http://bit.ly/2psMcjc

The content below is taken from the original (Dell EMC to release Azure Stack in small, medium and Oh My!), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (How to keep multicloud complexity under control), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (Amazon Chime Update – Use Your Existing Active Directory, Claim Your Domain), to continue reading please visit the site. Remember to respect the Author & Copyright.

I first told you about Amazon Chime this past February (Amazon Chime – Unified Communications Service) and told you how I connect and collaborate with people all over the world.

Since the launch, Amazon Chime has quickly become the communication tool of choice within the AWS team. I participate in multiple person-to-person and group chats throughout the day, and frequently “Chime In” to Amazon Chime-powered conferences to discuss upcoming launches and speaking opportunities.

Today we are adding two new features to Amazon Chime: the ability to claim a domain as your own and support for your existing Active Directory.

Claiming a Domain
Claiming a domain gives you the authority to manage Amazon Chime usage for all of the users in the domain. You can make sure that new employees sign up for Amazon Chime in an official fashion and you can suspend accounts for employees that leave the organization.

To claim a domain, you assert that you own a particular domain name and then back up the assertion by entering a TXT record to your domain’s DNS entry. You must do this for each domain and subdomain that your organization uses for email addresses.

Here’s how I would claim one of my own domains:

After I click on Verify this domain, Amazon Chime provides me with the record for my DNS:

After I do this, the domain’s status will change to Pending Verification. Once Amazon Chime has confirmed that the new record exists as expected, the status will change to Verified and the team account will become an enterprise account.

Active Directory Support
This feature allows your users to sign in to Amazon Chime using their existing Active Directory identity and credentials. After you have set it up, you can enable and take advantage of advanced AD security features such as password rotation, password complexity rules, and multi-factor authentication. You can also control the allocation of Amazon Chime’s Plus and Pro licenses on a group-by-group basis (check out Plans and Pricing to learn more about each type of license).

In order to use this feature, you must be using an Amazon Chime enterprise account. If you are using a team account, follow the directions at Create an Enterprise Account before proceeding.

Then you will need to set up a directory with the AWS Directory Service. You have two options at this point:

1. Use the AWS Directory Service AD Connector to connect to your existing on-premises Active Directory instance.
2. Use Microsoft Active Directory, configured for standalone use. Read How to Create a Microsoft AD Directory for more information on this option.

After you have set up your directory, you can connect to it from within the Amazon Chime console by clicking on Settings and Active directory and choosing your directory from the drop-down:

After you have done this you can select individual groups within the directory and assign the appropriate subscriptions (Plus or Pro) on a group-by-group basis.

With everything set up as desired, your users can log in to Amazon Chime using their existing directory credentials.

These new features are available now and you can start using them today!

If you would like to learn more about Amazon Chime, you can watch the recent AWS Tech Talk: Modernize Meetings with Amazon Chime:

Here is the presentation from the talk:

— Jeff;

The content below is taken from the original (Get ready to ‘spray’ touch controls onto any surface), to continue reading please visit the site. Remember to respect the Author & Copyright.

Nowadays we’re accustomed to the slick glass touchscreens on our phones and tablets, but what if we could extend such luxury to other parts of our devices — or to any surface, for that matter — in a cheap and cheerful way? Well, apparently there’s a solution on the way. At the ACM CHI conference this week, Carnegie Mellon University’s Future Interfaces Group showed off its latest research project, dubbed Electrick, which enables low-cost touch sensing on pretty much any object with a conductive surface — either it’s made out of a conductive material (including plastics mixed with conductive particles) or has a conductive coating (such as a carbon conductive spray paint) applied over it. Better yet, this technique works on irregular surfaces as well.

The sensing principle behind this is based on electric field tomography. Basically, the surface is surrounded by a number of electrodes (say, 8 to 16 of them, depending on the surface size), with one adjacent pair of electrodes injecting a small current to the surface, and the voltage at other pairs are measured. This cycle is repeated by rotating the pair of current-emitting electrodes. When a finger is placed on the surface, some current is shunted and thus reducing the localized voltages during each cycle, and by combining these cross-sectional measurements from all cycles, the finger’s 2D position can then be located. Electrick also supports multi-touch, though given the lower sensing resolution, it’s understandably not as robust as conventional touchscreens when the fingers are too close to each other.

Given how easy it is to apply Electrick onto any object and surface, this opens up all sorts of opportunities to both modders and manufacturers, and Future Interfaces Group showed off many cool ideas here. One of my favorites is the electric guitar demo: it’s sprayed with carbon conductive paint with electrodes attached along the edges, and after dragging the custom controls — a tremolo arm and a filter button, in this case — into the desired places using the companion app, the player can immediately use those features by touching the corresponding spots on the actual guitar. Similar functionalities can be applied to Play-doh, Jell-O and 3D-printed objects made out of conductive filaments.

Another interesting use case involved vacuum-forming Velostat (a carbon-loaded polyolefin film by 3M) onto the back cover of a smartphone, and with the electrodes attached, this enables the phone to detect different grips and thus toggle the corresponding apps. For instance, holding the phone horizontally by the ends of its top and bottom edges would trigger the camera app, and holding the phone vertically with both thumbs ready to type would trigger the keyboard.

Even car owners may benefit from this technology. In another demo, Future Interfaces Group sprayed carbon paint onto an ordinary steering wheel, and then attached electrodes to its outer edge. This effectively turned the steering wheel into a giant gesture input device for potential dashboard applications, and it could also serve as a hand detection feature to ensure safe driving.

Electrick isn’t limited to small objects; it can also work on large surfaces like desks and even walls. One demo added gesture input functionality to anywhere on a wall for controlling a light fixture: tap to turn it on or off, and drag up or down to adjust its brightness. And in case you’re wondering, the conductive carbon paint works under the protective latex wall paint. As for the desk demo, you can assign specific touch-sensitive spots for launching apps or toggling functions on your computer.

As simple as the technology behind Electrick sounds, it’ll still be at least a year away from commercialization, according to Future Interfaces Group director Chris Harrison (who also happens to be the co-founder and CTO of Qeexo, a UX startup spun out of Carnegie Mellon). That said, once the performance and noise filtering have been optimized, it’ll simply be a matter of packaging up the circuitry as a single chip or even applying it in software form.

Source: Chris Harrison (PDF)

The content below is taken from the original (Google makes it easier to read offline in Chrome on Android), to continue reading please visit the site. Remember to respect the Author & Copyright.

While apps like Pocket and Instapaper can help you read web pages on the go without a network connection, Google’s Chrome browser added the ability right into its Android app last December. Today, the company has tweaked the feature to make it a bit easier to download pages for offline viewing.

You can do a long press on any link in Chrome to find a new option to "Download link." You’ll even get this option when you tap and hold on any article suggestion on a new tab page. Further, when you get Chrome’s dinosaur image for any offline page, you’ll see a "Download Page Later" button that will automatically grab the page for you when you’re back online. Any articles you’ve downloaded will show up in your recent downloads list with a new offline badge — just open a new tab to see it.

Now, whether you are actually offline or just want to save web pages for when you are, Chrome has your back. You’ll need the latest version of Chrome (58) for Android to do it, though.

Source: Google

The content below is taken from the original (Google’s mysterious Fuchsia OS looks like an Android re-do), to continue reading please visit the site. Remember to respect the Author & Copyright.

When we last looked at Google’s Fuchsia operating system, it was very modest. While it was designed for everything from Internet of Things devices to PCs, there wasn’t even a graphical interface to show. Well, things have… evolved. Ars Technica has revisited Fuchsia several months later, and it now touts an interface (nicknamed Armadillo) that makes it clear this isn’t just some after-hours experiment. It’s only a set of placeholders at the moment, but it gives you a good idea as to what to expect.

The home screen is a large, vertically scrolling list of cards for "stories," or collections of apps and OS components that work together to complete a given task. There’s also a Google Now-style section that has "suggestion" cards for tasks — use them and you’ll either add to an existing story or create a new one. The prototype UI also includes a simple split-screen interface, and scales up to tablet size.

Fuchsia isn’t based on Linux, like Android or Chrome OS, but it still uses open source code that would let anyone tinker with the inner workings. Apps, meanwhile, are built using Google’s Flutter kit, which lets developers write both Android and iOS apps.

Things are clearly coming along. But there’s one overriding question: just what role will Fuchsia have? Google’s Travis Geiselbrecht stresses that this "isn’t a toy thing," but there’s no public strategy. Ars speculates that Google is treating this as a sort of Android re-do: what if the company could design a platform while dumping all the technology it no longer needs or wants, such as Linux or any traces of Java? The use of Flutter would let you run Android apps until there’s broader software support. It might take years before Fuchsia is ready for public use, assuming that’s the ultimate plan, but there could be a day where Android is no longer the center of Google’s computing universe.

Source: Ars Technica

The content below is taken from the original (BlindPAD’s tablet makes visual information tactile for the vision-impaired), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (New technique turns anything into a touch sensor), to continue reading please visit the site. Remember to respect the Author & Copyright.