Yes. AI (artificial intelligence) is maturing. AI is still limited to its narrow definition. It is not yet the general AI you see taking over Earth in those crazy science fiction movies. So, in this context, what does it mean that AI is maturing?

I just came back from IBM’s Think conference. Think is to IBM fans what Burning Man is to Californians and hippies, even if there is no obvious direct correlation between the two. It is a major conference, where over 30,000 people gather to learn and celebrate technology and its usage. I wanted to share with you some takeaways, specifically in the field of AI.

Maturing means that processes are coming into place. Maturing means that tools are addressing key issues like bias or usability. Maturing means that people have learned from previous errors. Those errors are analyzed and built open.

In a short interview with theCUBE, my friend Rob Thomas, summarizes some his vision and explains some key concepts:

• There is no AI without IA (information architecture).
• Methodology is definitely part of the process.

Let’s drill down into both of these concepts.

AI without IA

Information architecture is a requirement to artificial intelligence. At first, it almost seems tautologic, right?

However, when you look at the enterprise, this is not true anymore – if it has been at anytime. A customer of ours had 83 databases mixed in both on premise and in the cloud. Another started

Angular Unit Testing

Set Up

If you do not already have a basic Angular CLI project, check out Installing Angular CLI

Basic Debugging of Unit Tests

Continuing from the third article in this series, we are now set up to debug the individual unit tests to see if our variables contain the proper values, or why tests may be failing.
We will be using VSCode. Ensure you have Debugger for Chrome installed. In VSCode, Click Debug, then Install Additional Debuggers:

Open VSCode and create a Book model that will contain the results from our service mock data

Open registration component and have getResults call the registrationService to get books to register

If there are results, we want to set the results variable and call showResults

In VSCode, open registration component tests and create a test for the getResults function:

There are a few modifications to be able to mock the registration service in the test class

Be sure to include all of the imports at the top, specifically the service and “of” to return the data

registrationServiceMock – represents our mock of the service that we set on line 27

registrationServiceStub – acts as the actual service which returns resultsData, the mock data

spyon – used to check if a function was called and provide a custom value.  In this case we are mocking a call for the registrationService.getBooks function.  When we call the component’s getResults function, it mimics the call to registrationService.getBooks and the registrationServiceStub returns our mock data.

expect – takes a value to test against another value or state

Open a command prompt and go to working directory

Cd C:\proj\tutorials\unittests\angular-testing

Type command to execute tests

ng test

You should see all tests passed:

Now let’s open the Chrome debugger – Hit F12 and you should see this:

Type “debugger;” in the registration.component.ts file, getResults method:

Save the file and the browser will refresh and rerun the tests.  But now it will break into the debugger on that line

If you hover over the data variable, you will see its current value, which includes the single book mock data from the unit test.  You can also see it in the Scope section at the bottom

Click step over icon  Twice

You can see that since we have data, we step into the first IF to call showResults

You can also set a breakpoint in this view by clicking to the left of the line number, example line 33

With this breakpoint, we can step through other areas without having to add “debugger;” to the code

You can imagine how this simple debugging can be extremely helpful if a test is failing and it is difficult to identify the reason at first glance.

More information on Angular testing

Set Up

If you do not already have a basic Angular CLI project, check out Installing Angular CLI

Angular Unit Testing

Continuing from the second article in this series, we are now ready to create a service with unit tests.  First, we will install a package that will allow mocking data.

Open a command prompt and go to working directory

Cd C:\proj\tutorials\unittests\angular-testing

Install json server in order to create a mock data service

npm install -g json-server

Add a file to the root directory for returning mock data

Right-click>new file then type “mockdata.json”

Then copy this json data into the file and save

{"books" : [ {"id": 1,"rpice" : 14.95,"name" : "The Great Gatsby"},{"id": 2,"age" : 19.99,"name" : "To Kill a Mockingbird"}],"comments" : [{"id": 1,"date" : "03-18-2016","message" : "Great book!"},{"id": 2,"date" : "06-21-2017","message" : "A true classic!"}]}

Run the json server to test the api, type this in the command window

json-server –watch mockdata.json

You should see the server running to reveal 2 endpoints

Open a browser and type in the endpoints to see the data

Great, our mock data service is working!

Add a service to the project for the registration component
Open a command prompt and go to the project app directory:

Cd C:\proj\tutorials\unittests\angular-testing\src\app\registration

Enter the following to create a service named “registration”

ng g service registration

You should now see 2 new files added – registration service and its unit test file

In registration service, create a function that returns the mock data, include the imports at the top, include the url from the mockdata service along with the getBooks function

In registration component, call the getBooks function in onInit, include the registrationService in the constructor in order to use it, include RegistrationService in the import section

Open the RegistrationService and create a unit test for the service that will test that the correct action “GET” and the correct url is being called, include the code in this screenshot to set up the test

Open app.component and be sure to add HttpClientModule

Add HttpClientModule to the registration component import section beforeEach

Open a command prompt and go to working directory

Cd C:\proj\tutorials\unittests\angular-testing

Enter command to start the unit tests

ng test

You will see the browser open and show the 5 tests have passed, including the registration and service tests

While debugging, you probably do not want every test to run, add “fit” in front of a test and only that test will execute

Now you see that only showResults should set resultsExist to true executed

If you want all tests in a single file to run, instead of all tests, open the test.ts file

Add the name of the component you want to test on line 18

Save, you will see the tests refresh and only execute registration component tests have run

That’s a lot of information for now.  More to come in the next article that will include debugging unit tests.

Json server

Created for front-end developers who need a quick back-end for prototyping and mocking.

More information on json server

HttpClientModule

Configures the dependency injector for HttpClient with supporting services for XSRF. Automatically imported by HttpClientModule.

More information on HttpClientModule

Set Up

If you do not already have a basic Angular CLI project, check out Installing Angular CLI

Create and Execute Unit Tests

Open Visual Studio Code

File>Open Folder> C:\proj\tutorials\unittests\angular-testing > Select Folder

Expand the src>app node to show the app.component.

Open a command prompt and go to the project app directory:

Cd C:\proj\tutorials\unittests\angular-testing\src\app

Create a new component named “registration”

ng generate component registration

You should now see the new registration folder and components

Show the registration component in the app by adding it to the bottom of the app.component.html, remove the other links which are not necessary:

Run the ng serve command to build and run the code in a browser

ng serve -o

A browser should open with the basic Angular app with the registration component showing

Add the RegistrationComponent to app.component.spec.ts, delete everything else

Go back to the command line and hit Ctrl + C to stop the server, then type “y”

Type command to execute tests

ng test

The browser will open and should show a successful test run

Create a variable ”resultsExist” and 2 functions in RegistrationComponent to hide and show results

Default the variable ”resultsExist” to false

Open registrationcomponent.spec.ts

Add “showResults should set resultsExist to true” and “hideResults should set resultsExist to false”

You should now see the results of the 3 tests that are in registration.component.spec

It’s that simple.  You have just created 2 basic unit tests for the registration component!

More information on the unit tests

Our test component file “registration.component.spect.ts” was created for us when we created the registration component with the command “ng generate component registration”.

describe(‘RegistrationComponent’)…

The word “describe” starts a test block.  In this case, it is starting tests for the registration component, in other words, “for the registration component, include these tests”.  In the next tutorial we will be adding more test blocks.

beforeEach

“beforeEach” sets the dependencies before running the tests that follow.  You can see that it is setting the “fixture” variable to the component while creating it.  Then it is setting the “component” to the actual instance so we can use it to test methods.  Finally, we are executing detectChanges which triggers change detection where Angular checks property bindings.

‘should create’ – The first unit test provided by default

This test is given to use by default when the test file is generated.  It simply does a check to make sure the component is created.  Although it is simple, this test will fail if the file is missing a dependency, for example.

‘showResults should set resultsExist to true’

This is one of the tests that we created above.  First, we are calling the showResults method on the RegistrationComponent, then we are “expecting” the “resultsExists “variable to be true.

These are very simple tests just to get started.  Stick around for some more examples of how to set up more complicated tests and dependencies.

Attending the NG Conf in 2018 was quite an experience.  The organizers did an amazing job delivering a alot of good information along with some great presentations.  However, information related to unit testing was a bit sparse.  Throughout the conference I met a few people and had some good discussions on this topic.  Considering my experience at the conference, and taking away what I have learned, I put together a small series of tutorials aimed at getting someone started on testing as well as some examples on unit testing Angular components.  Let’s get started:

Installing Angular CLI

1. Download and install npm from here

2. Create a folder for a new project

ex: “C:\proj\tutorials\unittests”

3. Open a command prompt and go to that folder

cd “C:\proj\tutorials\unittests”

4. Type this command to install the latest version of the CLI

npm install -g @angular/cli



5. Create your new project, e.g. “angular-testing”

ng new angular-testing

This will create the project and install all the dependencies needed to create tests.

In command window, make sure you are in the project directory

6. Run the ng serve command to test the install and you should see that the code compiled

ng serve -o

A browser should open with the basic Angular app

That’s it!

NPM

Npm is the package manager for node.js.  It is used to help developers easily share package modules.

More information on npm

Angular CLI

Angular CLI is a command line interface for Angular.  It is used to create and maintain Angular applications.  When installing the Angular CLI, Jasmine and Karma are configured by default to use for testing.

More information on Angular CLI

Jasmine

Jasmine is an open source testing framework for JavaScript.  It does not come with a built-in test runner.

More information on Jasmine

Karma

Karma is a JavaScript test runner that provides tools to work with Jasmine from the command line.  It will run in a browser and execute the Jasmine tests.  The results of the test will show in the command window as well as the browser.

More information on Karma

Former Ancestry.com & AdvancedMD Transformation Leader to steer Veracity Solutions through next phase of aggressive growth

Salt Lake City, November 29, 2018: Veracity Solutions, technology consultant leader, today announced the appointment of John Esser as Chief Executive Officer and President. The appointment comes on the back of another strong year in which the company is making great strides and is rapidly approaching it’s highest revenue in company history.

Esser, the former transformation leader for multiple large tech companies, is a seasoned leader with a proven record of taking technology companies to the next level by accelerating their innovation, operational capability, and growth.

“I have admired and worked alongside John for 6 years, and am thrilled to see Veracity continue to grow under his leadership,” said Galen Murdock, Founder & Chairman of the Board for Veracity Solutions. “He is a man of integrity, a creative technology executive, and is deeply respected by his peers and the entire industry. Our clients and consultants are in masterful hands.”

As the transformation leader at Ancestry, John evangelized and led a pivotal DevOps transformation which ultimately resulted in a continuous delivery process going from 1 deployment every two weeks to dozens of deployments per day. At AdvancedMD, John introduced DevOps processes and tools to improve operations efficiency, as well as overhauling and modernizing SaaS operations.

Esser has held additional high-profile positions throughout his career. He served as a Cloud Evangelist and Migration Leader architecting and leading two all-in migrations to AWS.  Additionally, he served as an Agile coach leading the comprehensive and massive agile transformation of Ancestry.

In addition to his career experience, Esser is a known thought leader in the DevOps community and has spoken and keynoted at numerous conferences (Agile 20xx, Gartner, DevOps Enterprise Summit, QCon, AWS reInvent, ChefConf, and DevOpsDays) and is a co-founder of the FlowCon conference.  His work as also been featured in numerous whitepapers and case studies.

About Veracity Solutions

Founded in 1998, Veracity Solutions helps organizations plan, build and launch successful software solutions from conception through adoption. Companies solve their stubborn and unique problems at the core by relying on our expert advice, coaching, and staff. We can help you solve your critical business goals and lift your team in the process.

One of the great features introduced in AngularJS 1.x was two-way data binding. It was easy to add a ngModel attribute to an input and have that element be directly bound to a property on a JSON object. It was also just as easy to create a new UI element through a directive or component and model-bind it using ngModel and have the model binding pass from parent to child. Then Angular (2+) came along and changed everything with a whole new method for databinding controls and components.

Databinding is still a core part of Angular and ngModel still plays its part. But if you want to create a custom component that can databind using ngModel or it’s reactive form counterpart formControlName, there are a few more steps.

All of the code is available on my [Github Repo](https://github.com/JoelRichman/angular-data-bindable-component)

My business case in this example is a dropdown that populates from an API call that can be reused in multiple places and is data bindable.

We’ll start with a scratch Angular project created using the `ng New` method from the Angular CLI. Next, we’ll create our reusable dropdown component.

ng g component dropdown

There is now a folder called drop-down with the files for the new dropdown.component. I modified the template property to be a select element. For now, we will populate this select from an array. I’ve stripped out the constructor and onInit, which are not needed at this time.

‘We should be doing agile, right?’

Developers are naturally drawn to the idea of agile development. Speedy delivery cycles, with less planning and documentation…what’s not to like? Well, for starters, there’s the disconnect between theory and implementation when undergoing an agile transformation. Some organizations have a solid understanding of agile principles but can’t apply them. This can lead to uncertainty and skepticism about agile ideas.

To combat this, Veracity has found some success with a ‘delayed boot camp’. In this model, in-depth about agile training comes later in the agile transformation process. Usually, it’s after they’ve attempted a couple of agile sprints. This ‘learn by doing’ approach might sound counter-intuitive, but hey, stick with us.

Focus on the product, not the process

The beginning isn’t always the best place for an introduction. Development teams typically start their agile transformation with an agile boot camp or ‘agile 101’ session. There, everyone learns agile theory over a couple of days. After a PT planning or ‘Sprint 0’ exercise, the sprints begin…and sometimes sputter out. If you’ve been in agile development long enough, this might start to sound familiar.

Veracity found the problem was these early boot camps emphasized the process over the output. Vocal skeptics (we all know one), would distract the class and instructors found themselves wasting time wading through ultra-specific questions. The goal of software development should be to create high-quality value, faster. If that’s our destination, we can’t be too distracted nailing down the exact way to get there. We just have to get there.

Get everyone on the same page

The delayed boot camp model helps development teams stay focused on their product output. It starts with an inception and alignment exercise. At Veracity, this ‘I&A’ exercise is a two-day planning process with key stakeholders. These can be organizational leaders, the development team, even marketing and sales staff. Everyone should be on board with the agile transformation. The development team leaves the exercise with a release plan – and just enough background information about agile development needed to follow it. Then, it’s time to attempt a couple sprints before reuniting for the delayed boot camp.

The tailored I&A exercise helps get your team excited about your agile transformation. Why? Because it keeps the focus on application and output. Your team isn’t hyper-focused on becoming experts in agile development theory. They’re ready to build deliver value in the form of a superior product. And use agile as a tool to do it.

Regroup and dive in

When it’s time for the delayed boot camp (after about two sprints), your team can practice agile using real-life examples from their current projects. This can help reduce downtime and thwart would-be agile skeptics. Where traditional boot camps have struggled through hypothetical examples, your team can continue its hands-on learning.

Your team might not have found loads of success in their pre-boot camp sprints – and that’s ok! This is where experiential learning comes into play. Some aspects of agile will have clicked, others will be more challenging. But, because they’ll have already tried agile on their own. And we’ve found that means they’ll arrive at the boot camp ready to learn and with relevant, useful questions.

Keep moving forward

Life rarely gives us any ‘silver bullet’ solutions, and the delayed boot camp model is no exception. Agile transformations are challenging! Many organizations do find traditional boot camps to be effective. As with any shift within an organization, it’s important to remain flexible and positive as challenges arise. And it doesn’t hurt to celebrate small successes, especially early on. Stay positive, focus on the output, and find the agile process along the way.

Veracity specializes in helping organizations conceptualize, design, and build effective software. We believe that, by prioritizing planning early in the launch process, we can reduce time and energy wasted at the later stages. For more information, we’ve published an eGuide to help with your agile transformation. To get it, click here!

We just received news that Veracity is on the INC 5000 list again this year!

This is our sixth year on the INC 5000, which puts us in a pretty exclusive group. But even better, it’s tremendously gratifying to be back, after a couple of years hiatus.

Challenges? What challenges? Said no one ever when building & releasing software.

Just about any company that builds software, whether the intended end user is external or internal, will face a development cycle requiring their teams to strategize, plan, develop, launch and adopt. We call this cycle the Launch Continuum.

Across the phases of the Launch Continuum, we as builders of software see our strengths, and core competencies thrive, while many of our weaknesses express themselves as pains we might feel throughout our launch cycle. Initially, our most basic instinct and internal WebMD tells us to treat that pain immediately, many of us fail to dig deeper and find out what’s actually causing that pain. At Veracity Solutions we have developed a simple do it yourself assessment to help steer you towards asking the right questions and uncovering the root causes of your development pains.

What pains do we feel when launching new or relaunching existing software products?

Okay, take a breath. We don’t intend to cover every pain you’ve ever felt over the expanse of your career, but consider this, have you felt those same pains before, with other software releases? Or have those pains followed you from a previous employer to the “greener pastures” of your current position? We’ve found that many of these pains are universal and are respecters of no one. So what are they and how are they felt? Well, a few examples are; early in the strategy and analysis stage, there may be too many priorities stacking up or a lack of market knowledge impeding the process. In the planning stage, we’ve witnessed companies that are stuck validating design/features, it’s common to see scope creep act as a major irritant in this stage too. Even the more obvious challenges within the development stage such as wasted development or development delays that are painful and costly can be traced to a specific root cause.

Root cause? Please explain.

So we mentioned some common challenges during the Launch Continuum. What are some of the common root causes for the given examples? When dealing with too many priorities we can drill down to a few root causes 1) lack of a prioritization process 2) inability to say no to a customer or 3) not enough information to make a clear decision. One or more of these root causes can drive the pain(s) felt downstream.

Magic bullet: Shoot it to me straight.

In all honesty, there isn’t a perfect solution to every launch challenge. Not all can or will be identified upfront; nor will they all be corrected at their root cause on the first attempt. Our data shows the most significant success comes from aligning on the most impactful challenges and working to solve their root causes through a coordinated effort in all functions.  This assessment can be used across departments, to help you identify and align on the most high-value pains to be resolved.

Veracity Solutions helps organizations plan, build and launch successful software solutions from conception through adoption. Companies solve their stubborn and unique problems at the core by relying on our expert advice, coaching and staff. We can help you solve your critical business goals and lift your team in the process.