google Archives - Cache Prof

How to Kotlin – from the Lead Kotlin Language Designer (Google I/O ’18)

August 21, 2019

[MUSIC PLAYING] JAMES LAU: Thank you. Thanks for being
here this morning. My name is James, and I’m part
of the Kotlin team at Google. Today, I have the pleasure
of introducing a very special guest from
JetBrains, who really requires no introduction. Now, all of you know
that Kotlin is now one of the most
loved programming languages in the world. And at Google I/O,
it’s very rare for us to have external speakers. But this person
was here last year, and we invited him back because
we couldn’t think of anybody else better to teach
Kotlin, other than one of the people who invented it. So please help me welcome
the lead language designer for Kotlin, Andrey Breslav. [APPLAUSE] ANDREY BRESLAV:
Thank you, James. Thanks for a great introduction. Hello, everybody. I’m very glad to see you here. Today, I’m going to talk
about what can it be– Kotlin– I guess. And I really am going
to do a live demo, so please bring my demo on. So the reason why I have this
horrible code in the slides is that we are all learning,
and our old habits sometimes get in the way. So I’ll be presenting today on
the topic of how you get out of your Java habits and
get to your Kotlin habits. So we all come from different
backgrounds, of course. And many of us started with
the Java programming language and built up our knowledge
of programming through this. So we remember many things. And the thing is Kotlin has
been inspired by many languages, including the Java
programming language. So you can reproduce many of
the Java constructs in Kotlin. And it will work. You can get your
job done this way, but it can be, in many
cases, improved dramatically. So this particular example
is about declaring classes. And you can see here that I
have a Kotlin class on the left and the Java class on the right. And they look very similar. But this is definitely not
how we write Kotlin code. So what do you are
actually supposed to do is remove all the
unnecessary stuff. What I have to say here is
two properties, one class. That’s it, right? So I can try to
transform it by hand, but I actually want to
show off a nice tool. And simply copy and paste
the code from the Java side to the Kotlin side, so it
will use the Java to Kotlin converter built into the
IDE, and do it for me. So boom, there it is. A single line that’s
actually all you needed to declare one
class, two properties. That’s it. All I have here is a class
with a primary constructor. So it has two parameters and
both of them are properties. And that’s all
you wanted to say. So this is one of
the things that demonstrates how cheap
declaring classes is in Kotlin. And there’s a
consequence to this. So look at this code. Here, it’s obviously not how
you’re supposed to write code in any language, actually. I wanted to parse a full
name into a first name and a last name. And so that’s what
I’m doing here. But how do I pack the result
to put it out of the function? I don’t have a way of returning
two things from a function. I have to put into one object. And I’m abusing a list here,
then awkwardly taking out one and the other to make a
first name and a last name. Don’t do this in any language. But there is kind of
a psychological reason to doing this, at least
in our old habits, because declaring classes
is expensive, right? You have to create a new
file, put a lot of code in it. It’s kind of awkward. But in Kotlin, you
don’t have to do this. All you need to say,
my class, full name, with first and last
names as properties. And then, all I need to do
here is just return that. So my full name. Here it goes. And now instead of indices, I
can say first and last right here. So that’s the idea. Classes being
cheap is not always saving you time at
the declaration site, it’s saving you mental effort. You can represent your
multiple return as a class and it doesn’t
cost you anything. So if I run this, you’ll
see that my equals doesn’t work, obviously, because
that’s a single-line class. And so now I’ll go to
declare equals there, and then a hash code there,
and so on and so forth. It’s so verbose. But I really don’t need
to do this in Kotlin, because you probably
know that there is something called data classes. Who knows data classes? Many people, good. So you know that I simply
put this single keyword there and the compiler generates many
things for me– it’s equal, it’s hash code,
it’s to a string, and many other
convenient methods. So that’s it. Change your mind about
how expensive a class is. You can use it easily in
all your abstractions. So more or less done
with the warm up. Let’s look at something else– properties. So we talked about classes. We’ll go through properties,
and then go over to functions. So here is a property done
the way you shouldn’t do it in Kotlin, again. So the problems that
I showed you before were kind of one-liners where
both the getter and setter is trivial. If you want a custom
setter, you definitely don’t define functions for that. You have your custom setter
syntax, as you probably know. If you know data
classes, you know that. So inside a custom setter,
you have field to– not filed, but field– to write to your backend
storage, but that’s it. You don’t need to introduce
extra names in anything else. So that’s
straightforward, right? But then look at this code. So here is already
some sensible logic. I have two properties, one
of them private and nullable and mutable. And on my first access, I’m
checking if that’s null, and then I compute a
value and write into it. And then I output,
return it from my getter. So what is it? It’s a lazy property, right? I personally wrote
dozens and thousands of those in Java and
many other languages, so I got kind of bored by that. And that’s why Kotlin has an
abstraction mechanism called delegation for properties. So delegated properties
let you get rid of all the repetition
of this lazy logic. All we care about is
this expression here. So let’s just do it. Implement my property by
just lazy of all this. This is it. So what I’m having
now, I’m saying my property is not simply
initialized by something. It’s delegated to
this lazy thing here. And upon first access, this
lambda will be executed. And then, the rest will
be stored by the library. So lazy is not a
language construct, it’s just a library function. You can define your own. And the library provides
you with many other things. So the takeaway
here is that if you have a common kind of property,
like observable for example, when you need to be notified
that something was modified, use a library or write your own. So here, delegates.observable
does the job from the standard library. But if you like, you don’t
have to write code like this. When you have one property,
and then the other property, and the other doing the same and
same thing over and over again, all you need to do
is this, actually. Declare a single class
that encapsulates the logic of your property,
like your generic getter and generic setter. And that’s it. You can now simply refer to
this class in many properties and get your business
logic database access, all kinds of validation. Anything you like can be
abstracted as a library and then reused
across your project. Does it make sense? Who uses this already? I don’t know. So many people. You actually should. I’m sure you can
benefit from this. So this is more or less
it about properties. And now, let’s get to functions. Functions are very
important, right? So again, this is
very horrible code. Don’t write code like
this in Kotlin, please. This is very much
inspired by our habits in the Java programming
language, when I have to put everything into a class. So StringUtil– does your
project has its own StringUtil class? Oh, if it doesn’t, it’s just
a very new project, right? So any of my projects have them. But the thing is, in Kotlin,
it’s a little different. You don’t have to use a class. Well, first of all, Kotlin
classes don’t have statics. So to use these functions
from this class, you have to say a
StringUtil, parentheses, which makes a new object. I don’t want a new
object every time. I want it like this, so I turn
this class into an object. It’s a little bit of an
improvement in my insanity, right? So I was creating
an object every time I wanted to call a function. That’s crazy. But really, in Kotlin, I don’t
need any enclosing container at all because I have
top-level functions. So this may seem obvious like
functions, what are they? They’re just
declarations, right? But some languages have them
only in classes and many people learn this and rely on this. So this is a lot
more of a Kotlin way, but it’s still
not great in terms of what you can achieve with
Kotlin, because here, you have two overloads. So getFirstWord is
supposed to parse a string, find a first space, and take
the first word, and return it. But what if the separator
is not a space, but a comma or something? So here is a more
full-featured version. And then, this is how
you’ll call it actually in most contexts. So what I wanted to express
here is just a default value. In Java, we are used to
using overloads for this, and also some people
use nullable parameters like pass and null here, and
I’ll give you a default value. Don’t do this in Kotlin. You don’t need to. So all you need to do actually,
is simply specify your default. My default is space, here. That’s it. So there was no need
to emulate defaults. They are both into the language. And same for when you
have many, many default parameters with
different values, like multiple Booleans,
so on, so forth. You can just use named parameter
syntax to express which of them you actually need. And all of the rest
will be used by default. So this makes functions
fewer in the first place, and then a lot more expressive. OK. Good with functions, right? Well, actually, this
function is kind of midway between the Kotlin
style and the Java style because it’s actually
working on strings. Very much a good idea to put
this into a string class. Oh, wait, it’s not. Because the string class
is not controlled by you, you can’t put everything
into the string class. And you really want to keep
the string API minimal. So what I would
really like to do is something like this,
where I can say my string, getFirstWord, and that’s it. So it looks like a method. It’s called an extension
function, actually. It’s not sitting
in a string class. I didn’t go into the JDK and
alter the class I can control. But still, it works like this. So this is the
mechanism you can use. I’ll do it manually to
illustrate how it works here. So I have a receiver
of type string. Now, I don’t need this
parameter anymore. And I can say this dot
here, and use my this here or omit all of this
on the left-hand side. So now, I’ll be able
to use it this way. Make sense? I can do the same
with a property. Actually, it would be very
nice to do it this way– just so I have first
word as a property name. And you can have an
extension property. Of course, there will
be no customization for the separator, but
otherwise you’re good to go. Yep, I’ll just need
to put a space here. And that’s it. So extension functions,
extension properties– it’s actually a
very important idea. It’s not only just convenience. It allows you to keep your
classes really minimal. So look at the string
class in Kotlin. It’s only five methods. If you compare that to Java,
it will be screens and screens of declarations. So you can keep
your API minimal. And all the utility
functions can be extensions, can sit in different libraries,
can be modularized like this. And that’s a very important
tool for designing APIs. Do you have questions? OK. I couldn’t take them anyway. OK, now, let’s have
a look at this. Here, I’m doing
something very typical. I’m traversing a hierarchy. So I have containers
and leaf elements. Containers can be
nested in one another. Leaf elements sit there. All leaf elements
hold text and I want to extract all the
text from this hierarchy. Pretty straightforward. So my classes are
three lines of code– not much. There’s an element. There’s a container with
the list of children. There is text. Now, I’m traversing this. So I’m using
extension functions. I’m using top-level functions,
everything as I told you. So it’s all right, but
I don’t like this code. Why don’t I like it? Here, to traverse a
hierarchy, I need recursion. So I need to pass the string
builder down the stack and add to it as I’m
going down the tree. But then, I end up with
top-level function that’s only needed by this one here. So this one is not
really needed anywhere but inside this function. So what I’d really like to
do is just put it inside– just go here and make
it a local function. So again, it’s just expressing
that nobody else needs this. You don’t need private
helpers anymore– a look for local helpers. And this can be
improved a little bit. You can actually
make use of closure. So I can create my
string builder right here and get rid of all this. So I don’t need to return
or take parameters here. All I need here is use
whatever is declared above. And then I just do
extractText of e right here and return string
builder toString. ExtractText– oh, sorry– it’s
an extension function, right? No, sorry. Yeah, so here is how it goes. You can turn something into
a local function and leverage closure. So this variable is declared
outside my function. It’s not accessible to
anyone outside the outer. And I’m using it
here and that’s it. Now, local functions, extension
functions, top-level functions, default parameters– use these. They will make your code nicer. Now, let’s look at
what’s still there. Do you see grey code? Grey code is useless. The IDE and the compiler show
you that something is not needed there, and
it actually isn’t. This class is redundant because
we have this is check here. So you simply can remove this. And I don’t know if you see– oh, yeah, you do– but the text variable
has gone green. Why is it green? It’s because the compiler can
figure out the casts for you. It’s actually much safer. It’s not only convenient. I’m really annoyed at my
casts all over the place. So I know it’s text. Why don’t you know? Well, now it knows. And actually, you don’t
need this variable either because it’s the only usage. And it’s same thing here. And then, my container
can be inline as well. So here it is. I can use smart casts. It makes your code
safer, more concise. And actually, it makes
all the casts that still are in your program meaningful. So when you see an as
operator in Kotlin now, you know it means something. It’s not just a useless
compliment to the is check above. Also this thing here is kind of
stupid because what I’m doing, I’m just applying the same
function to everything. And it’s a single function. So what I want to do
is something like this. That’s a little
bit nicer looking. And then, let’s look
at what we have. We are traversing a hierarchy. I have my leaves. I have my containers. And that’s what I want
to express, right? I’m checking different cases. So to do that, it’s a lot
nicer to use a when statement. When can switch in
types right here. But there is an
annoying thing about it. And it’s again, coming
from my old habits. I’m declaring a close hierarchy. I have only containers
and text, right? I don’t have anything else. But now, I have this pretty
annoying else case right here. Why? Because the compiler
has no idea. I don’t have anything
but containers and text. It’s just an abstract class
and I have some cases there. But you can actually express
this in Kotlin with sealed. I can have a sealed
class, which means all the subclasses are known. You can declare them
outside this file. And this way, the
IDE and the compiler know that this else is useless. So we went from almost
two screens of code to less than one, simply
applying the idioms of Kotlin to this code. Do you have questions? I’m sorry. All right. So now, let’s just
continue with this exercise and look at some more examples
of expressions that are written like with old habits in mind. And we’ll try to transform
them into something better. So the first thing that
really stands out here is var. I can’t say never use var. Vars are useful. Mutable variables can be
used for many nice things. But it’s kind of discouraged. If you need a var, you
need a very good reason. Here is not good reason
using a val, definitely. Then here, let’s
look at these three. It’s repetition. Repetition is ugly. Repetition is
error-prone, especially if this was not a single
name, but many things chained. So I would like to get
rid of this repetition. What I can do is say, with ex. Does anyone remember Pascal? Pascal, anyone? Oh, good. Good. I started in Pascal, almost. So it had this weird thing,
which was a building construct. In Kotlin, it’s a function. We can use it. And here, we can get
rid of all the ex things here, just like this. And now it looks even
more stupid, right? I’m just assigning to
the same variables. Don’t do that. OK, so now I have a print line
with string plus something, string plus something,
string plus something. It’s awkward. Most languages now have
string interpolation. Kotlin has that as well. So what you actually
need here is this. OK, done with this one. Import things into
your scope with with. Use string
interpolation, it’s nice. Now here, I’m creating
a map the old way. I can kind of make it a
little nicer like this by using my operators,
but it’s really much nicer if I just use a
builder function. So what I can do here is replace
all my map things with pairs. Oh, not pairs, but pair, sorry. Typing when talking
is difficult. Yeah, so a map can be
constructed of pairs, right? And map was only a set of
pairs from key to value. But actually, pairs are
kind of redundant in this, so we’re usually using
the to function here. It’s not a built-in operator,
just a library function here, so this is how
you create a map. And when you want
to traverse the map, you can say here, key
and value, and just have your variables
like this, which makes for loops a lot more concise. This example of code,
with my if statement, is something I really hated
about my code in Java. Because these assignments here,
they all fall apart so easily, so I really like to do
things like this in Kotlin. So if, and many other things,
are actually expressions. This is something
pretty unfamiliar for the C language family. We are used to dividing
our code into statements and expressions, right? Statements are things
that have effects. Expressions are things
that have values. So you assign expressions to
variables and write statements to assign things to things. So Kotlin is halfway between
this procedural tradition and functional tradition. So we have a lot more
expressions than you’re used to in other languages. So you can do this here. And of course, you
don’t have to use a var. You don’t have to
make a different line. And you can assign
it right away. So if expression, make it nicer. By the way, the result
of the expression is the last thing in the block. So the same for when. When is not simply
switch case on steroids, it’s largely and
importantly, an expression. So you can also do
it like this, right? So not many returns
here, but one return here will be a lot nicer. Also you don’t have to repeat
yourself, of course, this much. And you can say even this. By the way, if you want to check
if something is odd and even, don’t do it like me. It’s only for demo purposes. Don’t try this at home. It will hurt. Yeah, so this one can be
further simplified like this. So again, you’re trying
to remove the noise. When you see code
like this, just try to get rid of the noise. Noise is harmful for your brain. Last thing, just a
quick demo of what do you do with nullability. So these question marks– who’s
familiar with nullable types in Kotlin? How many people? I’ll go really, really quick. So you can nullable types. And compiler makes you
do things like this. So it’s in there now. The string is nullable. You can dereference it. You can either do this,
which says just safely dereference me– which by the way,
you can do here as well so you don’t have
to write an if around it. And you can actually
simplify it like this. Another nice thing
is that you can use an elvis operator like
this, so to simplify your longer if statements into something. And this is kind of curious
because this is definitely in an expression
position, right? So how elvis works? Elvis takes an expression to
the left-hand side of a string, asks are you a
null really nicely. And then if it’s a null, it
evaluates the right-hand side. But the right-hand side has
to be an expression, right? Basically, it’s supposed
to be a default. So if you are now on
the left-hand side, use a default on
the right-hand side. But your default can
be just a return, which means that you don’t
compute any value there. You just jump out
of the function. And that’s a quite interesting
thing from the type system standpoint, but I’m not
giving a lecture here. I’m doing a demo. OK, we’re good with expressions. Let’s look at some
functional style. So people very often
refer to Kotlin as a functional language. I don’t think it is, actually. I think Kotlin is a
multi-paradigm language that supports functional style. You don’t have to write
functional in Kotlin, but it’s oftentimes
very nice to do it. So let’s have a look at this. So in my Java old
days in mind, I wrote this code, which just
goes over a list of numbers and picks those that
are divisible by 16, and then converts them to hex. So what it actually does
is filter map, right? Map is this one, and
filter is this one. So what I can do, even with the
help of my IDE, I can do this. So newer versions of all
programming languages have something like this. It can definitely leverage this. So this filter is a function. This lambda is a function value. You don’t have, by the way,
to declare it as a variable. You can just get rid of it. So that’s a lambda parameter. Kotlin has some nice
semi-functional things, like you can say anywhere in
your code, you can say also. You have this value, also do
this for me please– like print this list for me. And then proceed with
what you were doing. Like never mind this, it’s
just debug output or some side effect I want to insert here. Side effects are not very
functional, on the one hand. On the other hand, this is
very handy for debugging. You don’t have to break
your chain apart, and so on, so forth. Use also, use let, use
run, and so on, so forth. There is one very deep thing
about functional abstractions in non-functional languages. When I do something like this,
I have my repeat function right here, right? So what it does,
it takes a number of times I want to
repeat something, and this something
is a function. By the way, you don’t have
to invent your own function interface every time, just
use the function types here. It’s a function that takes
an int or it takes a unit. Unit is something
you don’t care about. Then, it simply
repeats it, right? So when I say repeat, I’m always
very much conscious about what it’s going to cost me. So it’s a function. It takes a lambda
as a parameter. So it’s actually just
another parameter. The Kotlin custom is to write
it outside the parentheses because it looks more like a
language construct like this. But then, OK, I’m running this. I have to create a
lambda object, right? I have to create a lambda
object every time I do anything like this. So there is a cost
to this abstraction. It’s nice code. I can reuse things. I can raise the level of
abstraction in my code. But there is a toll on that. Actually in Kotlin, you
can very often get rid of the toll of green lambdas– lambda objects– for you, by
just using inline functions. When I say inline, my
code doesn’t change. So here, nothing happened at
the call site that I can see. But if I say show
Kotlin bytecode, and just decompile
this into to Java– just to scare you a little bit. It was much of an
easy talk so far. So if I do this– here it goes– it’s
a simple for loop. Where did my lambda go? Well, the compiler
simply optimized it away. You don’t need a lambda. So if you simply have your loop
here and you inline everything, you end up with a loop. That’s it. So the big difference
in the mindset when you go from the
Java programming language to the Kotlin
programming language is that you still use lambdas,
but some of your lambdas are really free. And by the way, these
all are free too. So many, many lambdas
in the standard library are free abstractions. You don’t have to
pay for calling them. It’s just code
generated for you. So functional in Kotlin is not
only convenient, but also quite cheap. Speaking of cheap, by the way,
let’s look at this example. So here, I’m trying to do
a parallel computation. Well, it’s a stupid sample. Nobody does parallel
computation in bare threads, so on, so forth, but I
want to illustrate a point. So what I’m doing
here is, again, with my old habits in mind,
I’m creating 100,000 threads– 100,000 threads, each of
which does some work– actually, sleeps for one second
and just prints a number. And then, I have to
join all these threads to my main thread. So if I run this– oh, oh, oh, that
was an exception. What was that? The Java lang out
of memory error. Basically, what it’s
telling me, hey, you can not create 100,000 threads. Are you crazy there? It’s 100,000 stacks. It doesn’t fit into memory. Just get reasonable. And that’s fair. OS threads are not cheap. You have to allocate
resources for threads. So you don’t do such
silly things with threads, but I have this example
down through coroutines. Who knows about
coroutines in Kotlin? Oh, good. Who uses them in production? OK, soon enough you all will
be using them, I’m sure. So have a look here. It’s very much the same code. So I’ll just put it
side by side here. Very much the same code,
but instead of threads here, I’m creating async tasks
which are using coroutines underneath. So I’m still waiting for
one second and printing. And if I run this, there
is no out of memory. It’s printing all the
numbers and I’m good. So again, Kotlin
introduced coroutines as a means of making
your asynchronous computations nicer. And that works, but
what’s the cost of that? So the cost of that
is at least cheaper than having a thread
per each computation. Of course, nobody
does that exactly, but still coroutines
are very cheap. You can spin off like
100,000 coroutines, a million coroutines, and it doesn’t
cost you nearly as much as anything like
that old threads. Let me illustrate something
coroutines are really good for right here. So here is a legacy
interface or– I don’t know– or a [INAUDIBLE]
interface– whatever. So what we very often have to
do to make things asynchronous or make things like
reverse our dependencies, so on, so forth, is callbacks. So just ask me to do something. I’ll do it for you. And I’ll let you
know when I’m done. So here, I have my mock service,
a request, and a callback function that’s passed to it. So when the work in
the comments are done, I’m calling the callback and
just passing my answer there. So that’s all right. It’s working for
everyone, right? But this is what the
code looks like when I want to exchange messages
between two services. So I just want to basically
send two messages in sequence. And here is what I have to do. First, request. Then a callback. This is the result
of the request. I print it. Then next request
inside that callback. And then print inside. So you see the staircase
right here, right? One step– oh, sorry. One step, two
steps, three steps. And you can actually
get quite deep down this staircase,
which is not nice. So what I would
really love to do is something a little
more straightforward, but so this is
kind of tolerable. But what if– just
imagine– what if you needed to do like n calls? Just a number– like
make a list of calls. So this is the code I came up
with, which isn’t nice at all. So I definitely need
recursion there, because I have to nest a
callback inside a callback inside a callback, right? So I need recursion. This is the shortest code
I could come up with. It copies arrays. Don’t do that. It’s wasteful in
terms of memory, wasteful in terms of time. It’s quadratic. But basically, you
have to come up with something like
this– like nest callbacks into callbacks into callbacks. And so you can’t just say, OK,
repeat this five times, right? So what I really
want to be able to do is something like this, where I
just say, OK, send one request, wait for results, send
the other request. And then if I want
to repeat something, just repeat it with a for loop. So this code here is actually
using the same callbacks. Only the coroutine abstractions
are distributing this away from me. So actually, you can take any
callback-based API you have now, and turn it into this– like make it straightforward– with just a few lines of code. I’ll show you. So this is calling
the same services, because I have this
function right here. So what I’m doing, I’m
just turning the request into a suspension function
through this simple construct. That’s an extension function
of my callback service. The first thing I say there
is suspend my coroutines. So I’m assuming
I’m in a coroutine, I suspended it right away,
I get my continuation, and I do my request. That’s it. I’m suspended. I’m waiting for a request. So there it is. And when the request is done,
I just say resume to coroutine. That’s it. So this simple lines of code
turns your callback-based API into a coroutine API
and so makes this– oh, sorry– makes
this code into this, which is a lot more
readable to my sense. How do you like it? OK, I see some nods
in the audience. Thank you. Yeah, well, actually,
if you wanted to be a lot more prudent here– and I’m sure you want to– you need a catch exceptions. So catching– handling your
exceptions is very important. And that’s as easy as this. Just catch your exception. Whatever happens on
the– oh, so sorry. Not here, of course. Whatever happens
with your request, just catch it and
resumeWithException. So this will propagate
exceptions through coroutines very nicely. And you’ll be able to write
try catch around here– like surround this
with try catch– I’m sorry, whatever– and
catch exceptions there, as if it was sequential code. But underneath, it’s
all asynchronous. You can do HTTP requests like
this, asyncio, file systems. You can do background
threads– everything you need. See how isn’t it nice? And I guess, the last example
I’ll be showing you today is this one. It’s just another showoff for
how coroutines can help you. Take a look. So what I want to
do is to create an infinite stream of numbers. Who likes infinite
streams of numbers? I eat them for breakfast. So I want just a Fibonacci
sequence to be generated here. And then, I can take 20 of them. Here, just a sequence of 20. I can take 200, 2,000. I can filter, map,
slice, whatever. So this buildSequence
function is a library function in the Kotlin standard library. And it’s actually based on the
same mechanism as coroutines. It doesn’t do any
background processing. It’s all in the same thread. What it does, it takes all the
yield statements from here, and just puts them
in a sequence. So if I want to yield something
here, I’ll just do it. I insert 2 into my sequence. If I want to– say, if tmp is greater
than 10, continue– I can skip pieces of my logic. So that’s as straightforward
as any coroutine. It gives you a lazy sequence. So takeaways–
classes are cheap. Functions are
top-level or local. No overloading to emulate
your default values. Use properties, use delegated
properties, use coroutines. Have a nice Kotlin. And I want to advertise
some more activities today. So if you still have questions
that I couldn’t take, you can come over to an office
hour we’re having at 12:30. You can come over
to the sandbox area C, where we’re at the
Kotlin booth, some of the day at least. And right after my
talk, there will be a talk by Jake Wharton
about Android KDX, which is very exciting. I believe it’s on stage two,
so you’re welcome there. Thank you very much
for your attention. [APPLAUSE] [MUSIC PLAYING]

Articles, Blog

A Cool Desk Gadget Under $30

August 21, 2019

What’s up, guys? Lew here, back here with another video Today I’m bringing you a knick-nack… …patty wag give a dog a bone? What a *weird* intro I am calling it a knickknack because its like Sometimes people in the comments are like Lew, why are you showing me these things that are thousands and thousands and thousands of dollars? I want something more approachable that also happens to be cool, so. I’m hoping that this is one of those things. It’s called the SHARKK Hangover Something you can put on your desk, a place to keep your headphones, So that you can you know have them
organized especially if they have a cable or something and you can display
them you know nicely but it’s got a few USB ports which is gonna allow you to charge up
some devices it’s got audio pass through so if you
have a desktop computer or your audio source is somewhat hidden behind
the desk somewhere and you know changing out headphones and whatnot requires you
to reach down behind and so on this is an alternative it’s going to
allow for you to connect and disconnect right at the base Alright! So let’s.. let’s crack this
baby open gonna need a knife for that… OK some weight to it which is probably good! I’m going to put that there for a moment here’s the base… Cool..! Is it a hub or is it just power? let’s see here.. It is a hub! Not just
charge things but allow you to.. to have more peripherals connected to your
system essentially one goes to your system the other three sit out front here the
audio port i mentioned before and what looks like a power button and then a USB
cable slide it..Yes!.. that was easy the back for your cable I’ve got some headphones here let’s see
what this thing looks like if you caught the last video which of course you have you still have time it hasn’t
self-destructed yet then you probably saw these slick new
headphones from Odyssey! Look at the… This is what they look like it’s a bit of a look right there wait I
want to do it the other way there we go I like that look better on
your desktop you always know where they are look at that so now it’s plugged in
quickly try to charge the device will be in charge how about this i pad right here ipad so I try to plug the Sharrk into a power
brick and for some reason it was behaving like you wouldn’t it wasn’t passing
through charge to the other devices but the minute that i plug it into my laptop all of a sudden everything was charging
up correctly so the intention here as the manual states Lew why don’t you try reading the manual
first as the manual states this should be hooked up to your system
and then it can actually act as a USB sound card as well so these audio ports
they don’t require direct connection you’re the microphone and headphone the
sound card is like in the base so the USB is transferring the audio and now i
can plug directly into those locations there so again now you have access to your ports
through the USB hub as well as your audio through the built-in interface so
all you gotta do is connect this end here to an available USB port on a on a
computer could be Mac could be PC doesn’t really matter so you got this like cool this cool
little gadget on your desk multifunctional I don’t mind it sorry guys I’m just.. I’m enjoying myself

Articles, Blog

AutoML Vision – Part 1 (AI Adventures)

August 20, 2019

YUFENG GUO: One of the top
things that I get asked about is AutoML. In this two-part
video, let’s try using AutoML Vision to build and
deploy a machine learning model that recognizes
different types of chairs along with a few other items
sprinkled in for good measure. We’re doing it all– from the raw data
collection, all the way to serving the model, and
everything in between. Welcome to “AI
Adventures,” where we explore the art, science,
and tools of machine learning. My name is Yufeng Guo. And on this episode, we’ll
explore AutoML Vision, currently in alpha,
and get our data into the right
format as an input. In part 2, we’ll use this
data to build a model to detect what style of
chair is in a picture. One of the things that
makes AutoML so compelling is having a custom model. Existing models and services,
like the Vision API, have no problem recognizing
that these pictures have chairs in them. But what if you made
your own chairs, and that you needed
a way to catalog the various brands of different
chairs in your inventory? Wouldn’t it be nice to be
able to use a custom Vision API, so to speak,
which recognizes your particular chairs? That’s what we’re going to
try to do with AutoML Vision. AutoML Vision takes as
an input lots and lots of labeled photos. So get your camera out and
start snapping pictures. How many pictures you ask? Well, ideally,
you’d have hundreds of pictures per object. And that would be good. And then, once you get tired of
clicking that shutter option, perhaps you’ll try
doing what I did to get lots and lots of pictures. To make it easier to
capture data for AutoML, I chose to gather
my training data by capturing videos
of the chairs and then using the tool ffmpeg
to extract out those frames. I’ve gone out over to the
Google Sunnyvale campus. I took some videos of a variety
of different outdoor chairs. I also took some video of the
tables they were positioned around, as well as a bike– eh– just to make things a
little more interesting. Let’s take a look at
some of that footage now. Here, we have some chairs
of different shapes, styles, and colors. No video is greater than
30 seconds in length. And we have a short clip of a
table and another of a bike. That’s the data that we
will be working with. The end state that
we want is a CSV file that has one row per
image and two columns– the first for the location
of the image in Google Cloud Storage, and the
second for the label, like red chair or
table or blue chair. To make it easier to
organize, I placed each video in its own folder. So then we can run ffmpeg
on each video file in turn within those folders. That way, once the
frames are extracted out, you’ll have one folder
per label filled with images of just that label. This is a handy way to
organize your images and data. And it’s simpler than
having one massive folder of all the images intermingled. Next, we can upload images
to Google Cloud Storage, using gsutil, replicating
our folder structure of one folder per label. Now, it’s time to get to
work creating a CSV file that lists the path and label
for each image I wanted to include in my data set. Now, there’s lots of
ways to accomplish this. But I chose to spin up
a local Jupyter notebook and create a Pandas
data-frame that gets exported as a CSV file. Let’s walk through
that code now. OK, so here we are in
our Jupyter notebook. And I’ve imported
OS and Pandas, so we can work with the file system. And load up Pandas– that way we
can use that to export our CSV. I’ve listed out all
the folders that I want to use to pull in the data. And I’ve listed this
out here explicitly because, perhaps in
a different scenario, I might choose to use just
a subset of these folders to create a different
training set. So then we have a
setup here to create a dictionary of our
folder name and then mapping to an array of all
of our files for that folder. And so to do that,
first, I’m going to create an array of arrays
of just all those file names. Each inner array is all the
file names of one folder. And the outer array is
just for each folder. And so here, we’re listing
through all the files in a folder. So our data folder is here. And we’ll wrap that in an array
so that we can capture that. And so we can see,
here, I’ve printed a sample of one value, one
image, in each of the folders. And we can see that
they’re all different. So it looks like
we’re in good shape. And so we can take those two– our folder names
and all our file names– and zip them together. Pass them to create
a dictionary. Using that and our base
Google Cloud Storage path, we can glue these two
together, because we want to pre-pen the GCS, or
Google Cloud Storage path, in the final output. So what we want is
something like this, where we have the Google
Cloud Storage directory path, all the way out to the .jpeg
name, and then a comma, and then the name of the label. So in this case,
maybe we have a comma and then chair_black, like so. And so to do that, we’ll loop
over the entire dictionary. And for each file in
the array of file names in that dictionary,
we will put together the base Google
Cloud Storage path, along with the folder
name and file name, as well as that label. So now, what we have with us
here is an array of pairs. Each pair has that
path and the label. So we can take this
array and just pass it straight into a data frame. Pandas accepts that
format to create new data frames from scratch. And our data frame looks
exactly as we’d expect. We got all our paths
and all our labels. Now, we’re ready
to export to CSV. In this particular case,
we want to export such that we use index equals
false and header equals false. This is important and
can really trip you up if you forget to do this. Because if you leave
the defaults, which are index– true,
and header– true, the outputted CSV file will
have a header row of 0 and 1. And moreover, it will
have an index column that comes before everything
else, which is just going to be your 0, 1, 2, 3, 4, 5. So we don’t want any of that. We just want the
path to the file and the label, nothing else. So we use index– false,
and header– false. So if you organize your folder
structure the same way that I have mine, you can
take this notebook and, with a couple
of minimal changes, adapt it for your
use case as well. So I’ll definitely publish
this notebook and link to that down below in
the video description. All right, so now
we have a CSV file describing the location and
label for all the images in our data set. We’re ready to train our model. Join me in part 2
of this episode. And we’ll see just how well
this model can perform. Thanks for watching this episode
of “Cloud AI Adventures.” And if you enjoyed it, hit
that Like button down below. And be sure to subscribe to get
all the latest updates right when they come out. And while you head over
to part two of this video, I’m going to eat this– mm– apple. [MUSIC PLAYING]

Articles, Blog

Connect to Remote Computer – remote desktop connection with Android app

August 19, 2019

Tutorial shows you, how to connect to a remote pc over the internet Allow remote desktop connection on windows 10 and connect to your pc from smart phone or tablet using Microsoft Remote Desktop app Steps to follow Get a static local IP address for your computer within your home network Configure router to forward port 3389 Allow remote desktop connection on your Windows computer Configure your PC not to sleep or hibernate Configure Remote Desktop connection through a Windows Firewall Turn off antivirus, Test port 3389 Connect your Public IP address to host name (get free domain name) Keep your domain name pointed to your IP address always Find computer username and set password Download and install Microsoft Remote Desktop app on your android device Test 1: Connect to remote computer, using your Wi-Fi connection (Inside your network) Test 2: Connect to remote computer, using any internet connection (Outside your network) Get a static local IP address for your computer within your home network Here is my IP address, let’s change it to a static OK, now this is my static local IP address Configure router to forward port 3389 Along default gateway you can find your LAN IP Address Copy and paste it into your web browser, to open your router’s login page You can find default username and password for your router on this website All useful links can be found in the description Find default username and password for your model If it doesn’t work for you, reset a router password to factory settings On this website, you can also find port forwarding guide, for your model Allow remote desktop connection on your Windows computer Configure your PC not to sleep or hibernate Configure Remote Desktop connection through a Windows Firewall Also allow port through your antivirus or temporarily turn off it Test port 3389 Connect your Public IP address to host name (get free domain name) Create a new account and activate it So, I already have an account Click on DDNS tab and Choose SIGN UP In Host section, type any host name and choose domain name Now your public IP address is connected to domain name Keep your domain name pointed to your IP address always If you have Dynamic IP address that means, it can be changed from your Internet Service Provider at any time then download and install Dynu IP Update Client The primary goal of dynamic DNS is to keep the domain name pointed to the most current IP address at all times but If you have a static IP address you can skip this step Find computer username and set password Here is username Now let’s set the password Set a Strong password, It must be at least 8 characters long and contain alphanumeric, symbols, upper and lower case letters OK we configured windows 10 for remote desktop, now let’s move to Android Download and install Microsoft Remote Desktop app on your android device Test 1: Connect to remote computer using your Wi-Fi connection (inside your network) Test 2: Connect to remote computer using any internet connection (outside your network) OK, now you can connect to a remote pc from anywhere using Microsoft Remote Desktop app on your android smart-phone or tablet

Articles, Blog

Google Pixel 4 tease: what it means

August 17, 2019

– Google, what’d you do? If you didn’t see this week
Google just tweeted out a picture of the Pixel 4 months before it’s going to release it which
is not a thing companies do. And, so, I think it
means three major things and I wanna go through ’em. Okay, so, first, it shows
that they understand how leak culture works,
especially in Android, because you know how
the leak culture works, I know what the script looks like and companies never
admit that they do too. But Google’s now admitting that it knows. So, here’s the script. Act one is like, there’s a render. And then act two is we
start to see some cases so we can guess at the shape of the phone and then act three is we
start to get some leaks of what the features are gonna be and we start to know more
about what we should expect. And then, act four, is like
the thing falls off a truck and we see real photos
and, in Google’s case, sometimes, like, full on reviews before they’ve even announced the phone. And then act five, the big conclusion, the grand finale, the
executive walks on stage and says this is Pixel 4 and we’re like, yeah, dude, we know. We’ve already seen everything about it and it’s a huge let down. So, Google’s playing with
that script a little bit. So, I think that’s clever. There is a downside though,
and that’s what does this mean for the Pixel 3 which is now, like, the saddest sad panda of Pixel phones because no one’s gonna go buy this thing because they’re gonna wait for the Pixel 4 which has been officially revealed by Google itself. It probably means that Pixel 3 sales are even worse than we thought and we didn’t think Pixel 3 sales were that good to begin with. But, it also means that,
like, Google doesn’t care. It doesn’t need to make
money on the Pixel 3. It’s just gonna wait for the Pixel 4. So, the other thing
about phone leak culture is it’s all about hype and the hype cycle and it’s about you, like, imagining this phone that’s not out
yet is going to be great and will be the thing that you want. It will be your next. And, just putting out a
photo of it right away means that every time we
write about the Pixel 4 on theverge.com, we’re gonna
use Google’s official photo. It makes the hopes and dreams better. Every time an Android phone gets announced or released or reviewed
between now and then, you’re gonna compare it to this Pixel 4 which is going to be perfect and you’ve seen a nice photo of. It’s this empty vessel
to pour all of your hopes and dreams into. I’m pointing at the
Pixel 3 ’cause it is not an empty vessel, it is a sad,
terrible battery life vessel. But the Pixel 4 won’t
be, it’s gonna be great. Google knows that everybody thinks that because they tweeted the photo. We expect the iPhone 11 to
look pretty much exactly like the Pixel 4. It’s gonna have a big square
camera bump on the side and be glossy and black and whatever. And, the iPhone always comes
out a month before the Pixel and so when the Pixel would come out, people would be like, “Oh,
you just copied the iPhone.” But now, the Pixel got shown
first and so now the iPhone would be like, oh, you
kinda copied the Pixel. And that’s kind of, I
don’t know, funny to me. The second big thing that this tease means is we get to look at the
picture that Google tweeted and try and make some guesses about what the features of
the Pixel 4 are gonna be. The first thing that we
can see is, if you look at the back of that photo, it doesn’t have this two tone glossy versus matte finish that’s design language that Google has stuck with for three
years, which is exciting. Maybe this phone’ll look and feel a little bit more high end than before. Second, there’s no fingerprint
sensor on the back, and that’s important because it means they’re gonna find some other way to let you log in biometrically. Maybe it’ll be a real face
ID on Android, finally. Or maybe it’ll be an
in-screen fingerprint sensor. We don’t know but we do know
that fingerprint sensors on the back are so 2017, and
Google’s moving away from it. Most importantly, we know that there’s a big honkin’ square camera module and, sure, it’s gonna look like what the iPhone looks like and we’re gonna have big honkin’ square camera modules on all our phones now forever. Whatever. Inside that big honkin’
square camera module, though, are two camera sensors and up until now, Google has said they only need one to do lots of cool stuff
because they’re better at computational photography. So, if they’re adding
a second camera sensor, that means they’re promising they can do some really cool stuff with it. Will it be wide angle or telephoto? Will it have better portrait mode? What about those other little
dots that are in there? Is one of them the spectral flicker sensor like on the Pixel 3? Or is it like a time of
flight sensor with a laser? What’s the flash gonna be? Where’s the other microphone? Will they finally make
good video on the Pixel 3? There’s a lot of stuff
that we can speculate on but we know for sure there’s
a second camera sensor and that means that Google’s gonna lean even harder into photography on the Pixel. Oh, you know, there’s
one thing we can’t see in the photo but I wanna
talk about it anyway, and it’s this Project Soli rumor. If you haven’t heard of Project Soli, it comes outta Google’s ATAP division and it’s literally a tiny radar chip and it’s designed to let a device detect tiny little hand movements out in space. Nine to Five Google heard a rumor that it was gonna be there. XDA developers found code in Android Q that verified that and I actually got to try it four years ago. You see me use on a smart watch where I twist my fingers and it, like, adjusts the smartwatch or a speaker where I could use it for,
like, media controls. And we’re expecting
media controls to be the thing that happens on the Pixel. The last thing that this tease means, I think the most important thing, is that Google is raising
the stakes on itself. The Pixel 4 should be a,
like, truly flagship phone. It should be the kind of
phone we’ve been waiting for Google to make and
can compete head to head with the iPhone and with Samsung phones and with Huawei phones from a
hardware quality perspective in addition to a camera and
software quality perspective. Google acquired this HTC team,
they call it the Taiwan team. The first phone that they worked on fully was the Pixel 3A, but
the Pixel 4 is gonna be the first flagship phone that they work on and because the Pixel 3A exists, they’ve got a low cost option
which gives them permission to make the Pixel 4 even higher cost and we’re expecting
the Pixel 4 to get sold by all US carriers and,
probably, including AT&T. But, remember, it’s coming
out right after the iPhone and so, if Google wants to really prove that they can sell a lot of these and actually finally make
money and make hardware a real, real business, they’re going to need
carrier marketing support. They’re gonna be competing
directly with the iPhone for shelf space and ad
dollars and ad time. So, if the Pixel 4 isn’t just truly great, it’s gonna end up being the same thing that every Pixel phone
is, a really good phone that virtually nobody buys. So, add all of that up. You’ve got the understanding
of the hype cycle, you’ve got the ability to speculate on features based on the photo, and you’ve got this raising of the stakes. I think Google is saying that the Pixel 4 is gonna be something really special and, after all of that, it better be. Hey, thanks so much for watching. The thing that Google did was so wild, I just had to do a video about it, so I appreciate you comin’
along with this ride with me. Lemme know what your hopes
for the Pixel 4 are down in the comments and if
you don’t wanna spend that much money on a
phone, you should check out our Pixel 3A review, ’cause
that’s a pretty good option for not a lot of money.

Articles, Blog

VIDEO GAME KNIVES IN REAL LIFE

August 17, 2019

What’s up guys lew here back with another video and today and today We’re gonna we’re gonna do something strange. you know I receive boxes here at Unbox therapy, and I don’t always know What is in them, these my friends. are REAL LIFE counter-Strike knives What what do you mean? what so this company here is called believe they’re called Elemental knives, am I right about that I’m gonna link them in the description you could check them out . Interpretations of the knives that you use in the game This is video games come to life. So what we’re gonna Do is inspect these babies and see just how crazy? Videogame knives look in real life now also inside the box was this little slip here You can see with a special code for some cSGo skins, so yeah You want to follow these instructions if you’re the fastest to redeem this some free stuff? first one of the day ,now obviously this is a Slightly different video than usual, but I’m kind of pumped full disclosure. I’m not a counter-strike player myself So you guys are gonna know a lot more about these than I do? OHHHHH Whoa, It’s kind of like a rainbow thing going on Wow Now my feeling on these things is I mean They’re they’re mostly commemorative right like these are collectors type things that said I mean, holy smokes this thing is legit You happened to get attacked by a bear or something while you’re playing counter strike reach for the real deal? OHHH There’s something else. I did not know that this guy has a legit holder open that baby up Whoo get me the box? Combat training for years. That’s what Unbox therapy has truly been about it’s all a ploy to practice my knife skills on cardboard boxes Think about it boom pocketable I guess Flip style knife oh man. [oh] oh, these are crazy look at that this guy like the tiger situation in the gold it has a clip on it as well So you could put it on a belt so we got a little pouch here as well. Let’s see how this guy goes in There you go sweet, okay Man, these are sharp as well. I Like this one this one has you know this piece of steel goes across the entirety of the knife This is like from a durability perspective a very solid Long lasting idea here this guy up here’s for what like for skinning something? I think this these are like legit hunting knives this is the biggest one This could get wild you guys got to vote down below which one was your favorite This is the rambo knife right here I mean, you’re like almost in the sword territory at this point here That is a combat knife right there again a crazy pattern on that, this if you need something like this You’re a pretty serious dude Sylvester stallone special right there all right. Maybe something more practical here okay, so we got another flip style with that like Rainbow pattern Reflective a lot of different colors represented in there that’s really cool whoa Jack that’s not mean you can’t feel comfortable right now. Oh my God that looks dangerous Wow in this case. It just has a hard shell and Some cord here. Oh That is that might be the perfect unboxing look at that Classic combat look here. You know look at check out that spider-Man pattern on there that one feels really comfortable as well. Oh Yeah, another Kind of Hook Style going on Different color Pattern wow, what do you think about that right there? Okay Super gruesome looking, I’ll probably use it on watermelon myself. I’m a peaceful guy the last one Perfection [oh] It’s another Rambo joint with a different paint job on it. I mean come on This is still the one for me. I can see The Hardcore Csgo players getting amped about this knife collectors. What can I say? Thanks to elemental knives Very cool. You know who you are you’re the man

Articles, Blog

Computer Games:Play Dominos Effect on Your Google Chrome Browser

August 16, 2019

Welcome Friends to our new Genre of Videos in which we talk about Games. in this video we are talking about Domino Game which i have downloaded from Google web store Here it is lets open its now opening after choosing level 1 place the pointer where you want to place the stick similarly place the sticks so the yellow stick can fall at runtime. now run and wait Voila Now level 2 to cancel the stick move your pointer on that stick and click I hope you will enjoy it. i dont think that i can clear it.Its up to you that all for today.Follow me on twitter for more Videos like this.Subscribe ,Share and like.Thank You

Articles, Blog

Lenovo’s Smart Display: the first Google Appliance

August 16, 2019

(gentle music) – The new smart displays with
Google Assistant are here and this is the first one,
it’s the Lenovo Smart Display. It’s a Google Home with a screen, sure, but it’s something much
more interesting than that. It’s basically a brand
new operating system. So, here’s a question, what will Google do now that it has this brand
new clean slate to work with? So, what you’re looking at here is the 10 inch Lenovo Smart Display. It’s $249 and it has a really nice design. It’s got this bamboo on the
back and sort of a wedge shape. It looks way better than
the Amazon Echo Show. You can also get a $199
version that’s eight inches but it has a really
boring gray plastic back. Honestly though, I’d be happy to have this on my kitchen counter
especially if it were standing up like this because
it has little feet to do that but yeah, you can see the
software is not designed to work with it yet, Google
hasn’t finished that. The only thing that works on portrait mode is dual video calls. Anyway let’s suss out the
rest of the hardware here. My favorite feature surprisingly is this little tiny switch right here, which covers up the five megapixel camera. Now people can’t drop in on you like they can on the Echo Show but being able to cover
up the camera means I’m much more likely to put this thing in my bedroom or my bathroom. I keep a Google Home in my bathroom and it’s great so come at me. Anyway, the speaker is fine. It’s a 10 watt speaker
with two passive tweeters and if you’re hoping that
this relatively big size means relatively big bass, well sorry. It sounds about the same as
any other basic smart speaker. It’s nowhere near as good as the Sonos One or an Apple HomePod. A Smart Display can do everything that a Google Home or a
Google Home Mini can do but the really important thing
here is obviously the screen. This thing runs on all new
software called Android Things which is technically based on Android but this is completely different. Now the Core UI is still your voice but you can do stuff with the screen and the main thing you need to know there is swiping in from the left
edge serves as a back button. It takes you home, then to your photos and then ultimately to
the ambient display. Now when you’re on the home screen, you can tap on the weather, look at that. And then there’s a bunch of cards that basically serve to show you what you could do and what you can ask. And you’ll notice one of these cards is my personal calendar, it does show personal information on this screen. Luckily when you set
it up with your phone, one of the little options on there tells you that if you don’t
want your personal information visible to everybody in your house, you can just leave that off. So one of the things
that Google Home can do that’s great is it can
recognize your voice and set reminders or show you
your specific calender stuff but it has to recognize
your voice for it to do that and that doesn’t always work here. So if I were to sort of speak weirdly, hey Google, remind me to
buy cheese on the way home. – I couldn’t verify your voice
so I can’t set any reminders. – Hey Google, what’s next on my calender? – Your next event is called dinner. It’s today at 6:30pm,
located in Rosa Mexicano. – Hey Google, video call Felicia. – Making a video call
to Felicia Shivakumar. (device ringing) – Hey, how’s it going? – It’s dark on my side. (Dieter laughing) – Hey Google, show me
pictures of Vjeran Pavic. – Showing your photos. – There he is! What a guy. One of the big things to know about this platform is
there’s no apps per say, there are some third party integrations. So for example, here’s Spotify and there are a handful of
other apps that can have stuff displayed on the screen
but there’s no App Store and the touch UI here is pretty basic. It’s pretty basic but
it’s also pretty pretty. In terms of how software design can look, this is the clearest example of where I think Google is going. Since they didn’t have to deal
with any of the legacy cruft like they did on Android or Chrome. Google was free to just
make what it wanted to make and so what you end up with
is very fluid animations, really nice fonts, good drop shadows. It just looks great. If you ask it a how-to question, you might get a Youtube video instead of just like a weblink, so. Hey Google. How do I darn a sock? – Okay, playing how to
darn socks on Youtube. – Now, I’m a Youtube TV subscriber which means that I can just use this thing as a television by saying something like, hey Google, watch CNN. – Alright, here’s CNN on Youtube TV. – And as soon as this plays, I’m just watching live television. It also works with HBO Now if
you ask for a specific show. What it doesn’t have is Netflix or Hulu which is kind of a huge bummer but as long as you have a phone that has a cast button
like this Android phone, you can still cast stuff to it. You put it all together and this thing makes a really great kitchen TV but it only comes into its own if you’re fully bought in
to the Google ecosystem. So for example, I’m a Google Photo teaser and having Google Photos in my kitchen on the display is really, really nice. It also makes video calls with Google Duo which is also really good but
not that many people use it. Basically I see this thing as
a really good Google appliance which is, I don’t know, fitting because it goes into your
kitchen with other appliances. Oh, hey, one more thing, it also makes regular old phone calls which
is kind of a neat feature. Now, my favorite feature of
this thing might be recipes. If you start a recipe, it
shows each step one by one. It doesn’t move to the next step till you ask for it and
it stays on the screen. It’s really great and I hope that some day Google allows us to put
our own personal recipes on the thing cause right now it just pulls the recipes on the web. Actually, that’s a lie. My very favorite feature,
this is super dumb but my very favorite
feature is still timers, because on this thing, the
timer stay on the screen the whole time. You can even set multiple timers and they all stay on the screen. It’s not how the Echo showed us it, it’s not how the HomePod does it. It’s the most basic thing and
Google actually got it right. Everything here is pretty
simple, it’s clean and it’s fast. If you aren’t put off by the price, having a screen on a smart speaker is definitely better than not having one. If you already bought in to
an Amazon Echo ecosystem, should you switch to this thing? Nah, probably not but if
you’re using Google Assistant, I think this thing is great. It’s my favorite smart speaker with a display by a long mile
even though I still hate, hate saying hey Google
compared to just saying Alexa. More important to me, I hope that Google expands its platform to work with more third party software fairly soon. Maybe the most fascinating
part of this smart display is that just by adding a
screen to the Google Assistant, they’ve completely changed
how the Google Assistant answers questions so if you ask it how to do something, you
might get a Youtube video. If you ask it for photos,
you might get your photos instead of something from the web. If you ask it for a recipe,
you’ll get a webpage completely remade into
step-by-step instructions for you. It’s the culmination of everything Google has been trying to do with Search. Making it give you answers instead of just sending you to webpages. So, what happens when Google actually does have a clean slate to work with? Turns out it makes a really
great Google appliance. Hey everybody, thanks so much for watching and I don’t know if you’ve noticed but we’re in a whole different space here. We’re gonna build out a set, we’ve got this cool graphic behind us. Also, you should check out
vox.com’s video on road diets. I’ve been really into
smart scooters lately and a road diet is a really
good way to make roads safe for those scooters so take a look at it.

Articles, Blog

THE WEIRDEST SPEAKERS YET

August 16, 2019

What’s up guys, Lou here back with another video and today, I am gonna blow your minds. I’ve got speakers here with dancing water fountains inside. Why? I gotta be honest with you – I have no idea. I stared at it for a while, I said “There is no way this thing sound any good!” …but dancing water in the studio was just too compelling to pass up so these are the SoundSoul, 6 Watt, musical speakers. From the fabulous water dance speakers. This is a monumental occasion, Jack. I hope you appericiate it for what it is. They work of USB, they’re USB powered. You see here you could hook up a smartphone, laptop or otherwise. Obviously there is a big… Ughhh… …ambient compenent here. Maybe you are trying to show a lady friend just how… …established you are, like some, Michael Douglas type character. She comes over, you’ve got a pool table, It’s a white pool table… Maybe you’re drinking some champagne, cham-pan-neah! Let’s look at the speakers. Oh! Easy Ben! Hol-y, there is water, all I see is a little bit of water inside. Now that I didn’t know, was I’m gonna have to… – it’s now much water though. Is it actually water? Whole thing looks weird right now, okay? There’s one, there’s two. Ahhh… what a fun day this is. Oh, look, it’s mini USB – remember the other day I was… “What uses mini US… mini USB?” See some other cables here… Uhh mini-jack. That is the one I think I wanna use. Okay… I think I need USB power, give me a second… Oh! Those things are juicing right away! You thought you knew the world of tech, you thought it was all about the latest smartphone. Let me tell you something. Things are happening, beneath the surface, in the sewers of Gotham. The sewers are Ninja Turtles, what does it have to do with Gotham, they were always eating pizza those turtles. Should we play some music? Ooh, Oooooohhhh! Just dancing with my… water here… completely normal. What a weird combination! Who said “That’s what I need!” Go back to the drawing board, these figures are not good enough, I need more WATER (Music Playing) I’m gonna hit the lights. Ooh, so emotional right now… No idea what I am doing right now! Get’n naked! With the lights! Nothing says romance like water in your speakers! Am I yelling?! (Laughing) I don’t know, these are weird, but I like weird. Are they the best sounding? No, hell no, they are not! Are they the best looking? No, hell no, they are not. But will they get people talking, are people gonna say “What is up with those things?” – hell yes.

Articles, Blog

FluMoS mobile | Connecting a CS 1000 Contamination Monitor

August 15, 2019

Step 1:
To begin, make sure the latest version of the FluMoS mobile application is downloaded
from the Google Play store on your Android Mobile Device. The version must be v01.10R06 or newer. Step 2:
Be sure the contamination monitor is correctly positioned in a vertical orientation where
the direction of flow is south to north. Note:
The Contamination Monitor must be receiving flow at the time of connection. Step 3:
Connect the 8-pole m12x1 communications and power cable to the Contamination Monitor and
the opposite end to the corresponding Sensor 1 input of the CSI-C-11 ConditionSensor Interface
Module. Step 4:
Connect the 5-pole m12x1 end of the power supply adapter to the CSI-C-11 ConditionSensor
Interface Module. Step 5:
Connect the opposite end of the power supply adapter to a suitable electrical receptacle. Step 6:
Open your Android’s mobile device settings and connect to the wireless network HYDAC_AP
once it become available. Step 7:
Open the FluMoS mobile application, wait until the LED on the CSI-C-11 has changed from Amber
to Green and select the wireless LAN Area Network Connection Icon to wirelessly connect
to the CSI-C-11 ConditionSensor Interface Module. At this point, the FluMoS mobile application
should immediately connect to the CSI-C-11 and data measurements will automatically begin
recording. Note:
If the devices fail to connect, refer to Troubleshooting Step 7.A. If the devices connect successfully,
but the LED on the CSI-C-11 is illuminating red, refer to Troubleshooting Step 7.B. If Troubleshooting Steps 7.A and 7.B do not
help solve your connection problems, please refer to the user manual or contact Schroeder
Industries Technical Support at [email protected] Step 8:
The CSI-C-11 will begin logging data measurements upon successful connection to the Contamination
Monitor. The individual measurement points are collected
into a LOG. Each LOG is given a name and a date/time signature. To transfer a data log, select the desired
data log, followed by the download icon. The data log will now be downloaded to your
device, where it will exist under the ‘Mobile’ tab. Step 9:
To transfer the data to your personal computer, select the data log under the ‘Mobile’ tab,
followed by the Export icon. You may export the data as either a .dat file
or a .csv file or both .dat file and .csv file formats. The .dat file is compatible only with the
FluMoS light software, where the data can be automatically tabulated and graphed for
Rate Of Change (ROC) trending purposes. The .csv files can be viewed in most spreadsheet
programs, but will only be transferred as RAW data. Users of the .csv file type will be able to
create their own tables and Rate Of Change (ROC) metrics. Step 10:
Once the file types have been chosen, you may select the export destination and transfer
the data log files. Step 7.A:
If the devices fail to connect, check the LED on the CSI-C-11 module. If the LED is illuminating RED, a processing
error has occurred. Disconnect all cables and begin from Step 1. Step 7.B:
If the devices connect successfully, but the LED on the CSI-C-11 module is illuminating
RED, select the settings icon, followed by the Device Settings icon. In Device Settings, you will be able to adjust
the Smart Sensor Count, Device Address, and Save Time. Be sure the Smart Sensor Count is set to 1,
and the Device Address is set to a. Save Time allows you to adjust the duration
between data measurements. Select the OK icon to save your settings and
the device will automatically restart. Proceed to Step 7.

Older Posts