The Ashcroft Law Firm First to Adopt Encryption Technology from KoolSpan to Protect Client-Related Voice and Data Communications

Leverages industry-leading mobile device encryption engine from KoolSpan to enable safe and secure calls and text messages

BETHESDA, Md. and KANSAS CITY, Mo., July 9, 2013 /PRNewswire/ -- The Ashcroft Law Firm, LLC becomes the first national law firm to safeguard client-related voice and data communications from being intercepted or compromised through a strategic relationship with KoolSpan Inc., the developer of a suite of hardware-based security applications.

The Ashcroft Law Firm is using KoolSpan's  patented TrustChip®, a self-contained, secure, military-grade, microSD encryption engine. The hardware anchor for KoolSpan's entire suite of secure encryption applications, TrustChip also powers security offerings for S-1, the Samsung-affiliated global leader in mobile security, and AT&T's voice encryption platform.

"In our business, advanced security is a must. Our team has worked with government leaders and corporate executives around the world to respond successfully to some of the most serious security threats, financial crises and litigation challenges of the past two decades," said Lori Sharpe Day, Managing Partner, the Ashcroft Law Firm.  "Operating with the highest level of integrity is a core principle of everything we do.  As digital communications become ubiquitous, this increasingly includes the integrity of the information entrusted to us by our clients, and the work we do on their behalf via voice and data communications."

"Encryption has long been used to protect the information of generals, diplomats and governments. Today, the same cybersecurity threats of unauthorized interception and hacking of voice and data threaten a myriad of organizations," said Gregg Smith, CEO of KoolSpan. "Recent news about increasing threats and privacy breaches, including domestic revelations that the National Security Agency (NSA) is collecting information about individuals' communications, have left Americans hyper-aware of the prominence and potential impact of phone and data hacking. Industry leaders like the Ashcroft Law Firm are moving the needle forward by implementing proactive measures to protect their client's confidentiality."

About The Ashcroft Group, LLC

Founded by former U.S. Attorney General John Ashcroft, The Ashcroft Group, LLC specializes in strategic consulting for world-leading corporations in the areas of National Security, Corporate Governance, Litigation Strategy, Crisis Management, Regulatory Advice and Entrepreneurial Ventures. With decades of public service and business expertise, The Ashcroft Group has worked extensively with leaders in the corporate world and international community, as well as with officials and advisors in the top levels of state, federal and foreign governments. For more information, visit http://www.ashcroftgroupllc.com 

About KoolSpan Inc.

KoolSpan Inc. develops hardware-based encryption and security applications to protect data and voice communications over network-connected devices. The foundation for KoolSpan encryption is TrustChip®, a hardware-based security platform delivered through a secure microSD processor. It protects connected devices including cell phones, office network phones, laptops, tablets, PCs, desktop phones and servers. With 17 patents underlying its technology, KoolSpan offers communications security to companies and government agencies worried about loss or theft of intellectual property, vital information and proprietary assets. TrustChip's TrustSDK is FIPS 140-2 validated and deployed in more than 50 countries. KoolSpan is a privately held and based in Bethesda, Md. For more information, visit www.koolspan.com

Jason Heller
201-465-8030
jheller@beckermanpr.com 

SOURCE KoolSpan Inc.

Part 2 of this SAMGradientView tutorial covers how to make a good open source library. I cover writing a good readme, writing documentation, testing, and publishing a pod to CocoaPods. Check out Part 1 if you missed it before.

Links from the Video

• Part 1
• SAMBadgeView: github.com/soffes/SAMBadgeView
• MIT License: en.wikipedia.org/wiki/MIT_License
• CocoaPods: cocoapods.org
• SemVer: semver.org
• SSToolkit: github.com/soffes/sstoolkit

The post Setting Up Open Source and Live Coding with Sam Soffes – Part 2 appeared first on Treehouse Blog.

The following is a guest post by Hugo Giraudel. Hugo has written several times for CSS-Tricks including an article about a rather clever Pie Timer and several entries for the Almanac. I'm glad to have him back, this time explaining some pretty hardcore Sass stuff with a really practical application.

Hey guys! I'm glad to be able to write for CSS-Tricks again and share some cool tricks about Sass! In the past few weeks, I've been intensively experimenting with Sass lists. I have found a lot of things that likely most people don't know.

I recently built a @mixin to create stripes. The idea is to give the mixin a regular gradient and it will turn it into a striped one. Since it turned out to be a fairly complicated thing to do, I thought it could be a good idea to write up.

Let's begin with some reminders about how gradients work.

Striped Gradients

When you give a gradient two succesive color-stops with the same stop value, the transition between them two is abrupt instead of smooth. It is technically a gradient, but there is no smooth transition from one color to another. Consider the following code:

.el {
      /* This is smooth */
      background: linear-gradient(deepskyblue, tomato);
    
      /* This is striped */
      background: linear-gradient(deepskyblue 50%, tomato 50%);
    }

Check out this Pen!

You may put as many color-stops as you want as long as you remember to give each color-stop the same stop-value as the previous one (except for the first).

.french-flag {
      height: 10em;
      width: 15em;
      background: linear-gradient(
        to right, 
        blue 33.33%, white 33.33%, 
        white 66.66%, red 66.66%
      );
    }

Check out this Pen!

That's pretty much everything you need to know about gradients for this article. If you ever happen to be interested in digging deep into the gradients, Ana Tudor wrote a wonderful article about this.

Sass Lists

Let's take this from the very start. Lists in Sass are quite similar to arrays in JavaScript. To initialize a list: $list: ();.

Note you can also initialize it with $list: null; (or even $list: unquote("");) if you feel like it, but beware they are different. Anyway, here is a very simple Sass list:

$css-tricks-is: (#b4d455, 42, "awesome");

This gets a bit more complex, because the Sass syntax is very permissive when it comes to lists. You can do a ton of things, some of which you're not supposed to. Let's take them one by one.

You can ommit braces.

You are not forced to wrap your lists with braces and can totally ommit them if you feel like it. We often ommit them to be honest.

$css-tricks-is: #b4d455, 42, "awesome";

The first index is 1

Not 0 like arrays. This is unfortunate since it makes our upcoming example code more complicated. This is an important thing to know when you're manipulating indexes with the nth() function.

$item-1: nth($css-tricks-is, 1); // #b4d455

You can separate values with spaces or commas.

Both are perfectly valid. I'm pretty sure you'll prefer commas since it's the standard separator for array values (JS, PHP...) but you can totally use spaces if you feel like it.

$css-tricks-is: #b4d455 42 "awesome";

You can mix spaces and commas.

You can have the first-level list comma-separated and the nested one space separated in nested lists. In the following example, the 3rd value is a space-separated list.

$css-tricks-is: #b4d455, 42, "awesome" "interesting" "free";

You can ommit quotes around strings.

That's right, strings are not necessarily quoted in Sass. Don't ask me why.

$css-tricks-is: #b4d455, 42, awesome;

In any case, I highly recommand you:

• keep the braces
• use commas
• quote your strings

It will save you some time, trust me.

The Striping Function

Let's get to the point of the article: our striping function! The main idea is to take advantage of the fact Sass lists can be comma-separated, just like color-stops in gradients. To put it simply, a list like $list: red 20%, blue 55% could be used in a linear-gradient() function as is: linear-gradient($list) outputing linear-gradient(red 20%, blue 55%).

Because we're badasses, we want to make it as flexible as possible. So:

• we can define a collection of color-stops
• we can define a list of colors if we want all the stripes to have the same size
• we define a direction as a default so we can ommit it in some cases

Thus we need two things to turn a regular gradient into a striped one: the list of colors / color-stops (e.g. deepskyblue, tomato, lightgreen or deepskyblue 20%, tomato 35%, lightgreen 62%) and an optional direction. Let's start with the skeleton:

@function stripe($colors, $direction: "to bottom") { 
        /* Core */
    }

As of $colors, there are 3 different scenarios available:

• The user passes a comma-separated list of color-stops: (deepskyblue 20%, tomato 35%, lightgreen 62%),
• The user passes a comma or space-separated list of colors: (deepskyblue, tomato, lightgreen),
• The user passes a single color: deepskyblue or (deepskyblue).

Everything else will either dump out invalid output or throw a Sass error. The function is meant for informed developers in a development environment so it's really no big deal if we don't cover every single edge case.

The very first thing we have to find out is whether we are dealing with a list of colors or a list of color-stops. The easiest way to find out is to check the first item in the $color list (with type-of()). If it is a list, then we have to deal with color-stops else the user wants all stripes to have the same width and it's pretty easy for us.

Unfortunately, we cannot do $auto : !(type-of($first-item) == list) since Sass doesn't recognize this as valid syntax. So to check, we can use the if() Sass function which comes close to the var = condition ? true : false statement of other languages.

$auto: if( type-of(nth($colors, 1)) == list, false, true );

To sum up, if $auto is true, it means all stripes will have the same size so the calculations are handled by Sass. If it's false, it means we have to deal with custom stops. We still need two variables before looping through colors: one in case we are running in auto-mode to define the size of a stripe; and one to store our color-stops while looping (later returned in a linear-gradient function).

$stripe-width: 100% / length($colors); /* Only used in auto mode */
    $gradient: ();

Now we can loop through colors / color-stops and add things to our $gradient variable. To add a numeric component to our loop, we use a @for loop instead of a @each loop. It doesn't make things much harder though. We also declare 2 new variables inside the loop: one for the current item and one to store the current color-stop before appending it to $gradient.

@for $i from 1 through length($colors) {
        $item: nth($colors, $i);
        $dump: ();
    }

This is where things get complicated. First, we have to differenciate auto mode from hard mode: color-stops are not the same. In auto mode, they are calculated which means in the first loop run (when $i equals 1) the "previous color-stop" equals 0% ($stripe-width * ($i - 1)). In hard mode, we have to check whether we're in the first loop run or not because nth($colors, 0) isn't allowed; it throws a Sass error. Let's check the code:

@for $i from 1 through length($colors) {
        $item: nth($colors, $i);
        $dump: ();
    
        /* If we're in auto-mode,
         * $item equals a color,
         * color-stops are automatically calculated based on $i
         */
        @if $auto == true {
            $dump: $item $stripe-width * ($i - 1), $item $stripe-width * $i;
            /*      red   0%                      , red   50%
             * ^ This is what the first loop run would output with a 2 colors gradient
             */
        }
        
        /* If we're in hard-mode
         */
        @else {
            /* We check if it is the first run loop;
             * if it isn't, we add the current color with the previous stop
             */
            @if $i > 1 {
              $previous-item: nth($colors, $i - 1);
              $dump: $dump, nth($item, 1) nth($previous-item, 2);
            }
            /* No matter what, 
             * we add the new color stop
             */
            $dump: $dump, $item;   
       }
    
       /* And no matter what, 
        * we append $dump to $gradient using join(),
        * separating both with a comma by forcing it as a 3rd argument
        */
       $gradient: join($gradient, $dump, comma);
    }

At the end of the loop, we have a well formated list ready to be used in a linear-gradient. We only need to return it with the appropriate syntax:

@return "linear-gradient(" #{$direction} "," #{$gradient} ")"

Small problem: Sass is returning the quotes as well, so we need to tell it to return the whole line without the quotes. Easy enough, we simply wrap it with #{}. Here is the whole function now:

@function stripes($colors, $direction: "to bottom") {  
        $stripe-width: 100% / length($colors);
        $auto:         if( type-of(nth($colors, 1)) == list, false, true );
        $gradient:     ();
        
        @for $i from 1 through length($colors) {
            $item: nth($colors, $i);
            $dump: ();
          
            @if $auto == true {
                $dump: $item $stripe-width * ($i - 1), $item $stripe-width * $i;
            }
          
            @else {   
                @if $i > 1 {
                    $previous-item: nth($colors, $i - 1);
                    $dump: $dump, nth($item, 1) nth($previous-item, 2);
                }
                $dump: $dump, $item;
            }
    
            $gradient: join($gradient, $dump, comma);
        }		
        @return #{"linear-gradient(" #{$direction} "," #{$gradient} ")"};
    }

Demo

As a demo, I took the header of Treehouse's blog: a line made of about 50 colored stripes. It looks absolutely lovely. They currently use 50 spans. Ouch! They could use stripped gradients instead, and it's easy now with this function.

I made two versions: the first one is running in auto-mode, meaning all stripes have the same width; the second one use custom color-stops to reproduce Treehouse's effect.

/* Colors only (auto-mode) */
    $treehouse-auto: #fa9300, #66c9ee, #c9c9c9, #82b964, #d24d33, #fffbdb, #2e77bb, #6bd5b1, #f87aa0, #c9c9c9, #72664e, #ccd600, #fffbdb, #df620e, #993838, #ff9600, #d24d33, #8960a7, #82b964, #f87aa0, #d43f3f, #668000, #ff9600, #8960a7, #c9c9c9, #993838, #ccd600, #668000, #f4cc13, #72664e, #fa9300, #66c9ee, #c9c9c9, #82b964, #ccd600, #fffbdb, #2e77bb, #6bd5b1, #f87aa0, #c9c9c9, #fa9300, #66c9ee, #c9c9c9, #82b964, #ccd600, #fffbdb, #fa9300;
    
    /* Color-stops (hard-mode) */
    $treehouse-hard: #fa9300 2.61%, #66c9ee 4.35%, #c9c9c9 6.96%, #82b964 9.13%, #d24d33 11.3%, #fffbdb 13.91%, #2e77bb 16.52%, #6bd5b1 17.82%, #f87aa0 19.12%, #c9c9c9 21.29%, #72664e 23.9%, #ccd600 26.07%, #fffbdb 28.68%, #df620e 31.29%, #993838 33.03%, #ff9600 34.33%, #d24d33 36.94%, #8960a7 39.55%, #82b964 42.16%, #f87aa0 43.36%, #d43f3f 45.63%, #668000 47.8%, #ff9600 50.41%, #8960a7 51.71%, #c9c9c9 53.88%, #993838 55.18%, #ccd600 57.79%, #668000 59.53%, #f4cc13 60.83%, #72664e 63.44%, #fa9300 66.05%, #66c9ee 67.35%, #c9c9c9 69.96%, #82b964 71.7%, #ccd600 74.31%, #fffbdb 76.92%, #2e77bb 79.53%, #6bd5b1 80.4%, #f87aa0 81.7%, #c9c9c9 83.87%, #fa9300 86.04%, #66c9ee 87.78%, #c9c9c9 90.39%, #82b964 92.56%, #ccd600 95.17%, #fffbdb 97.34%, #fa9300 100%;
    
    /* Using a pseudo-element to display it, no extra markup */
    .header:after {    
        content: '';
        position: absolute;
        left: 0;
        right: 0;
        top: 100%;
        height: .5em;
        // Auto
        background: stripes($treehouse-auto, to right);
        // Hard
        background: stripes($treehouse-hard, to right);
    }

As a result you can see the auto-mode at the top of the following pen and the hard-mode at the bottom. The later definitely looks better.

Check out this Pen!

Another use case could be helping out with the fluid width columns of equal height trick (see the Doug Neiner method).

Final words

I think we're done team. If you prefer a mixin to a function, it is fairly easy to edit: simply change @function to @mixin and the return line to something like background: linear-gradient(#{$gradient}, #{$linear}) then use it with @include stripes($colors). I personally prefer using a function for these things, but it's really up to you.

What do you think?

If you feel like you could make the code easier, please be sure to tell! Thanks for reading. :)

Create Striped Backgrounds With Gradients (and a Sass Function) is a post from CSS-Tricks