6 Meaningful Christmas Gifts for 2019

girl offering a wrapped gift

You know the drill. Your kiddo sees a toy. They want to have it. They need to have it. You secretly oblige in anticipation of Christmas. Morning comes. They tear through the wrapping paper so that shards of confetti fills the room. As paper flies everywhere, you see the smile on their faces. It’s exactly what they hoped for (insert excited shrieks)! And then weeks pass, maybe even just days, and that new toy they had to have is of no interest to them at all. Rather than storing unwanted toys in the closet this year, give the children on your list meaningful memories instead. Here are six connection-based gift ideas for ages two and up that we love for the holidays and all year long.

Big Life Journal (Ages 7+)

Big Life Journal for Kids helps children develop strong growth mindset skills through inspiring stories, colorful illustrations and engaging guided activities. Children discover how to believe in themselves and face challenges with confidence. They learn that mistakes are opportunities to grow and that they can achieve anything when they're persistent!

Big Life Journal

Why we love it: If you are a parent, grandparent, sibling, relative or friend, you can participate by being a child's  Journal Buddy. Spend quality time sharing, growing and connecting. Some of our inside favs include a gratitude scavenger hunt and the “Follow Your Heart” poem. And they have a special teen edition too!  

Silly Street Board Game (Age 4+)

Silly Street makes character builder games and toys that support cognitive learning and life skills. Silly Street Board Game helps to build qualities of confidence, creativity, empathy, adaptability, and grit.

Silly Street Board Game

Why we love it: This fun family game is pure silliness, just as the name implies. We love creating the board (yes, it’s a fun puzzle). Each card instructs you and your co-players to do fun, goofy tasks. This game gets the family thinking and moving. Be prepared for a good belly laugh!  

GoZen! (Age 5 to 15)

Feeling good is a skill! GoZen! uses animated videos to teach skills of resilience and well-being. Imaginative games, workbooks, cartoons, and quizzes help enrich this unique experience.  Why we love it: This innovative and interactive tool helps break down life’s big skills into bite-sized pieces for kids. It talks about sometimes complex things like feelings, stress and more in ways children understand! The animated characters help children learn to better understand what is going on inside of them using all of their senses and can be used with or without an adult.

Barefoot Books Mind and Body Set (Ages 4+)

This gift set includes two empowering practices that can be shared with children and adults alike. Yoga Pretzels includes 50 yoga activities and Mindful Kids includes 50 mindfulness practices that encourage kindness, focus and calming skills. These fun, powerful tools help build strength from the inside out to support all-around wellness.

Barefoot Books: Yoga Pretzels and Mindful KIds

Why we love it: Yoga pretzels is a great way to get moving (and laughing) with your favorite kiddo. The partner poses and movements are a fun way to build connection as well as inner strength and confidence.  We love Mindful Kids for its whimsical illustrations and easy to follow practices for cultivating focus, love, and stillness --- helpful for silencing the mind before bedtime. Some of our inside favorites are Sharp Eyes, Mountain Rising and Open Ears.  

Kids Cook Real Food (Age 2 - 13+)

This family-friendly cooking opportunity is a multimedia online course designed to help adults (yes you mom, dad, grandma, grandpa, aunts, uncles, etc) teach children how to cook. The courses are set up for a span of ages, from tots to teens, by offering beginner, intermediate and advanced level meals.

mom teaching her daughter to cook

Why we love it: This is such an amazing opportunity to spend time with your child and co-create meals from the heart. The recipes use real food from scratch, without the processed stuff. The Recipe Book is packed with recipes the whole family can enjoy. Food allergy? No problem. The course provides many substitutions for special diets. The focus of the course is less about the recipes and more about spending time together to learn, create and connect.

Generation Mindful’s Time-In-Toolkit and SnuggleBuddies

Ok, since connection is our jam, we would be a bit remiss if we didn't mention two favorites from our own community -- the Time-In-Toolkit and SnuggleBuddies. The Time-In-ToolKit is a step-by-step guide for nurturing social and emotional skills in children through mindfulness, child-led play, and positive discipline. This ToolKit includes PeaceMakers mindfulness cards and other playful activities that make learning about emotions fun, moving families and classrooms away from time-outs to Time-Ins! Generation Mindful Time-In-Toolkit The SunggleBuddies plush toy collection helps children name and share their feelings in daily playful ways, decreasing meltdowns and helping children feel safe. There are 7 different animals to choose from. Each plush comes with four mood emojis in a back pocket and a laminated feelings poster, calendar/journal. Generation Mindful SnuggleBuddies Why we love it The Toolkit’s superpower is in its Calming Corner, a space you create with your child (you too grandparents)! Together, you have the opportunity to design the space, choose calming tools and toys and further connection through naming and taming big emotions. Bonus, siblings love it too. We love the SnuggleBuddies because they are cuddly, relatable and engaging. The emojis make it easy for even young kids to share what they are feeling inside. The SnuggleBuddies are also great for military families and/or any family who has members living in different households/countries etc. PRO TIP: Grab a SnuggleBuddies and facetime your loved ones! This plush will get your child thinking and talking about their day. ----------------

Generation Mindful creates tools, toys, and programs that nurturing emotional intelligence playfully. Join 100,000 members and receive joy in your inbox each week including four free gifts when you join.

Which Is Better: Smoking Or Vaping?

Crazed Marijuana Vaping (e-Cigarette) Trend The vaping craze took the world by storm and caused a lot of fuss! It is one of the hippest trends and many people have started to use e-cigarettes instead of the traditional tobacco ones. The same thing goes with cannabis usage, as many users have walked away from traditionally [...]

The post Which Is Better: Smoking Or Vaping? appeared first on GC.

Handling Authentication Requests with Selenium – Part 4: NTLM Authentication

Now that we've created a thorough intellectual framework for how to handle authentication requests using Selenium in combination with a web proxy, and thanks to our last post, we can handle more than Basic authentication, let's take things a step further, and see how you can use Selenium in automating pages secured with NTLM authentication. Before we can do that, though, we need to have an understanding of how NTLM authentication differs from the previous types of authentication we've used before. NTLM authentication is a Microsoft-developed technology, originally implemented in the company's IIS web server product. It's not widely used on the public internet, but it does integrate nicely with things like Active Directory, so it can be quite useful for web applications used on company intranets that require security based on Active Directory credentials. This means that to provide sample code, we'll need to have a few things in place first. First, we'll need a test website that we can run locally, running on a server that implements NTLM authentication. Since we're working in C# in this series, we can create an ASP.NET Core web project to do that. Second, we'll also need to host the application using Windows. Even though the ASP.NET Core project can run against .NET Core, and that can run on platforms other than Windows, we'll need to actually run on Windows to take advantage of NTLM authentication, unless we want to introduce a ton of complexity with Active Directory domains and the like (which we don't for this post). Finally, most browsers bypass the use of a proxy when running strictly on localhost. This means that if you're running things all on the same system, you'll need to either configure the browser not to do this, or trick it into thinking the site the browser is connecting to isn't the local machine. The latter is far easier, since it only involves adding a line to the Windows hosts file (located at %WinDir%\System32\drivers\etc\hosts). On my test system, I've redirected www.seleniumhq-test.test to 127.0.0.1 by using the hosts file, and the sample code will reflect this. NTLM authentication is a challenge-response based authentication scheme, and it differs from other HTTP authentication schemes in that it authenticates a connection, not an individual request. This means that the browser and server must support so-called "keep-alive," or persistent TCP connections between them. It also means that our proxy has to support persistent TCP connections, and must allow us to use that exact connection for making the requests. Fortunately, the proxy we've been using so far, BenderProxy, does support this. The challenge-response mechanism used is complicated. Very complicated. So again, we'll be using the PassedBall library to parse authentication headers and generate authorization responses. It also requires multiple request/response round trips to perform the authentication handshake. Here's the implementation code for handling the NTLM authentication challenge for a sample site hosted on our local host machine: Note carefully that the initial 401 Unauthorized response may contain multiple WWW-Authenticate headers, so one may need to make sure the proper one is being used to interpret the response. Browsers, when faced with this, will usually choose what they perceive to be the "strongest" authentication method. In our case, we need to do that determination for ourselves. We'll wrap up this series with one more post, summing everything up.

Handling Authentication Requests with Selenium – Part 3: Beyond Basic Authentication

In the last post in this series, we saw the general procedure for handling authentication requests with Selenium and a web proxy:
  • Start the programmable proxy
  • Start a Selenium session configuring the browser to use the proxy
  • Wire up a method to intercept the 401 Unauthorized response
  • Use the method to resend the request with the correct Authorization header value
As we noted previously, the use of the Basic HTTP authentication scheme is rather weak. There are other authentication schemes that don't require the sending of a password in plain text over the wire. One such case is HTTP Digest authentication. Let's see what that looks like. First, let's navigate to a page that implements Digest authentication, and examine what we see. As before, we'll use the hosted version of The Internet at http://the-internet.herokuapp.com/ Browser sends: GET http://the-internet.herokuapp.com/digest_auth HTTP/1.1 Host: the-internet.herokuapp.com User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:67.0) Gecko/20100101 Firefox/67.0 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Language: en-US,en;q=0.5 Accept-Encoding: gzip, deflate Connection: keep-alive Upgrade-Insecure-Requests: 1 Browser receives back: HTTP/1.1 401 Unauthorized Connection: keep-alive Content-Type: text/plain Content-Length: 0 Www-Authenticate: Digest realm="Protected Area", nonce="MTU1ODkwNDI2MyBkYjYzMTA0ZTY0NmZjNmZhNDljNzQ2ZGY0ZTc3NDM4OA==", opaque="610a2ee688cda9e724885e23cd2cfdee", qop="auth" Server: WEBrick/1.3.1 (Ruby/2.2.5/2016-04-26) Date: Sun, 26 May 2019 20:57:43 GMT Via: 1.1 vegurTTP/1.1 200 OK  Note the value of the WWW-Authenticate header, which is considerably more complex than in the Basic authentication scheme case. The algorithm for figuring out the correct value for the Authorization header is likewise much more complex, which, in the simplest case, involves getting the MD5 hash of the string "userName:realm:password", then the MD5 hash of the HTTP verb and the URL of the resource being requested, then getting the Base64-encoded string of those two hashes along with the "nonce" value send in the authenticate header. Whew. That's an awful lot to keep straight. Probably a little too complicated to post the code for resolving all of the nuances of it within this blog post. So it's time to introduce a new library to add to our toolbox for calculating the authorization header value for any of a variety of authentication methods. That library is called PassedBall, and it's available both on GitHub and as a NuGet package. Since PassedBall supports Digest authentication, and using the same process as in our previous post, here's the implementation of the method to intercept and resend the HTTP request: Now that we have a library and generic framework for the generation of arbitrary authentication schemes, we'll look at one last approach for authentication, one that uses connection semantics for authentication, NTLM authentication.

Handling Authentication Requests with Selenium – Part 1: How Does Browser Authentication Work Anyway?

In order to understand how to use browser technologies to automate pages that use some form of authentication, it is useful to know what happens when you browse to such a page. What's actually happening when your browser prompts you for some form of credentials, usually a user name and password, before it will let you access a given resource on the web? At the risk of dropping down to a ridiculously low level, let's talk about how browsers transfer data for browsing websites. First, an obligatory disclaimer. I'm going to deliberately gloss over using pages served via secure HTTP ("https"), and I'm going to ignore mostly-binary protocols like HTTP/2 for this series. Those items, while important, and may impact the outcomes you see here, are beyond the scope of this series. Most of the time, a browser is using the Hypertext Transfer Protocol (or HTTP) to communicate with a given web server. When you type in a URL in your browser's address bar, your browser sends off an HTTP request (that's what the "http://" means at the beginning of the URL), and receives a response from the server. For the following examples, we'll be using Dave Haeffner's excellent Selenium-focused testing site, The Internet, which is designed to provide examples of challenging things a user might encounter when automating web pages with Selenium, and a hosted version of which is available at http://the-internet.herokuapp.com. Here's what a typical exchange might look like: Browser sends: GET http://the-internet.herokuapp.com/checkboxes HTTP/1.1 Host:the-internet.herokuapp.com User-Agent:Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.0 Accept:text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Language:en-US,en;q=0.5 Accept-Encoding:gzip, deflate Connection:keep-alive Upgrade-Insecure-Requests:1 Browser receives back: HTTP/1.1 200 OK Connection: keep-alive Content-Type: text/html;charset=utf-8 Content-Length: 2008 Server: WEBrick/1.3.1 (Ruby/2.2.5/2016-04-26) Date: Thu, 23 May 2019 23:44:54 GMT Via: 1.1 vegur <body of HTML page here> This is what happens for virtually every time a browser makes a request for a resource. The important thing to note is in that first line of the response. The "200 OK" bit means that the server had the resource and was sending it in response to the request. Now let's look at a request for a resource that is protected by authentication: Browser sends: GET http://the-internet.herokuapp.com/basic_auth HTTP/1.1 Host: the-internet.herokuapp.com User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:67.0) Gecko/20100101 Firefox/67.0 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Language: en-US,en;q=0.5 Accept-Encoding: gzip, deflate Connection: keep-alive Upgrade-Insecure-Requests: 1 Browser receives back: HTTP/1.1 401 Unauthorized Connection: keep-alive Content-Type: text/html;charset=utf-8 Www-Authenticate: Basic realm="Restricted Area" Content-Length: 15 Server: WEBrick/1.3.1 (Ruby/2.2.5/2016-04-26) Date: Thu, 23 May 2019 23:52:24 GMT Via: 1.1 vegur Note the all-important first line of the response, which says "401 Unauthorized". That tells us that we have a page that requires authentication. Note that if you asked your browser to browse to the page http://the-internet.herokuapp.com/basic_auth, you would have been prompted for a user name and password. Note in the response the line that says Www-Authenticate: Basic realm="Restricted Area". That tells the browser that the "Basic" authentication scheme is expected, and that the user's user name and password are required, and so the browser prompts you, and then it re-sends the request to the server, but with an additional header. If you used the proper credentials for the aforementioned URL (user name: admin, password: admin), you'd see something like the following: Browser sends: GET http://the-internet.herokuapp.com/basic_auth HTTP/1.1 Host: the-internet.herokuapp.com User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:67.0) Gecko/20100101 Firefox/67.0 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Language: en-US,en;q=0.5 Accept-Encoding: gzip, deflate Connection: keep-alive Upgrade-Insecure-Requests: 1 Authorization: Basic YWRtaW46YWRtaW4= Browser receives back: HTTP/1.1 200 OK Connection: keep-alive Content-Type: text/html;charset=utf-8 Content-Length: 1643 Server: WEBrick/1.3.1 (Ruby/2.2.5/2016-04-26) Date: Thu, 23 May 2019 23:59:31 GMT Via: 1.1 vegur <body of HTML page here> Clearly, that additional header that says Authorization: Basic YWRtaW46YWRtaW4= tells us that the browser must've done something with those credentials we gave it. If only we had a way to intercept the unauthorized response, calculate what needs to go into that authorization header, and resend the request before the browser had the chance to prompt us for credentials, we'd be golden. As luck (and technology) would have it, we do have exactly that ability, by using a web proxy. Every browser supports proxies, and Selenium makes it incredibly easy to use them with browsers being automated by it. The next post in this series will outline how to get that set up and working with Selenium.