The primary piece of learning for me with this assessment was everything related to the front-end of the application. Creating a Web API in .NET and using Entity Framework is where my core developer strengths lie. While The Fellowship doesn't currently use .NET Core anywhere, my side projects and code experiments have all been in the new libraries as I prepare the team to make the shift. This was a fun little activity as a way to quickly get the basics of how Angular works - creating components, routing requests, abstracting communication with the server, and binding with the user input.
<blockquote>
The final post in a four-part series of posts on <a href="/series/technical-assessment-series">'An Assessment of a Technical Assessment'</a>.
</blockquote>
Framing this mini-project as a look into whether this is the "best I can do", it certainly falls short. In the interest of time, there were several features that I had to cut.
<ul>
<li>There is no meaningful user input validation</li>
<li>I never found the right place to use <code>ngrx/store</code> in the application.</li>
<li>I did not implement any server-side data validation</li>
<li>I did not create/implement a SQL Server database, instead just using the <code>InMemoryDatabase</code></li>
<li>I did not roll out a SQL migration script or do any custom model building</li>
<li>There is no retry policy on persisting requests to the database</li>
<li>Error logging is non-existent - I could have easily dropped in Application Insights, but it seemed overkill for this project</li>
<li>There are no unit tests, integration tests, or other automated testing to ensure the code is working as expected</li>
<li>There is minimal dependency injection, only for passing the data context around.</li>
<li>Least importantly, the UI looks terrible. But I never claim to be a designer, so I'm ok with that.</li>
</ul>
This project serves well as a Proof of Concept. It shows that I can quickly learn the basics of a new (to me) JavaScript framework, put together a simple solution to prove I can do it, and check it all into GitHub for others to examine.

Technical Assessment - Final Notes

I am starting to make some real progress with this. I have a better idea of how components, service injection, and input binding works in Angular. These are all concepts that I am very familiar with in my extensive use of <a href="https://knockoutjs.com/">Knockout</a>, but anytime one is learning a new framework, there will be a learning curve in figuring out how this particular framework implements various features. Next on the requirements list is the ability to create a new blog post.
<blockquote>
The third in a four-part series of posts on <a href="/series/technical-assessment-series">'An Assessment of a Technical Assessment'</a>.
</blockquote>
<h2>Creating a Form</h2>
Back to the Angular tutorial, this piece took several steps to get to where I needed to be to start writing code. Unfortunately, the opening tutorial (<a href="https://angular.io/tutorial/toh-pt6#add-a-new-hero">Add a new hero</a>) only shows how to declare an input's id and then how to wire a button to pass the value of that element back to the component. This works fine for a single value, but I need the ability for a user to edit multiple fields and send them all to component. I now needed to jump into the "Fundamentals" section of the docs; specifically, the "<a href="https://angular.io/guide/forms-overview">Forms</a>" section.
I decided to do a quick shuffle of files, and move the <code>blogpost</code> model into the "blogposts" folder. This is one of those decisions that I couldn't tell if it jives with convention, but it felt a little dirty keeping component-specific files in the root "app" folder. It's decisions like these that I'm excited to learn more about as I dig into larger Angular projects.
Creating the form, adding some styling to it, and binding it to a model in the component was all pretty straight forward. This is another case where knowing how one MV* framework (Knockout) informed me on what I was looking for, and the tutorial did an adequate job of showing how to put that concept into practice. After a bit of trial and error, I assembled the necessary controls to display a half-way decent form.
<img src="/images/techass-create-new-blog-post.png" alt="Create New Blog Post">
Working through everything, now was the time for the big test - would it actually submit my data to the server?
<img src="/images/techass-post-request-body.png" alt="POST Request Body">
Huzzah! This part works - now to the API controller to see if it's receiving the data.
<img src="/images/techass-modelbound.png" alt="Controller Model Binding">
Ok - well, it wasn't really that easy. I had to do a bit of refactoring from the default template. They were all expected changes, though. This part of the project was what I was most confident that I could get working fairly quickly.
I created a <code>BloggingContext</code> to handle the ORM side of things, and to make it easier, I just mapped it to an <code>InMemoryDbContext</code>. Changing the connection to a SQL database or an Azure Cosmos Db account would be fairly trivial.
<h2>I Think I'm Done</h2>
At this point, the chief requirements are completed.
<ol>
<li>Allow the user to view blogs posts in chronological order</li>
<li>Allow the user to create a blog post</li>
<li>Allow the user to remove a blog post</li>
</ol>
I'll write one more post about where I would take the solution from here if I wanted to really put together a complete software package.

Technical Assessment - Adding Create Functionality

Now that I have a static list, the next step is to make it slightly more dynamic. This means that I need to learn how to send something back to the server, instead of just retrieving data from the server. My guess is that a delete method should be easier than an insert of a new record, though I expect them both to be about equal. The first piece I recognized that I needed to add is an identifier for indicating which record to delete. I am a big fan of using a <code>Guid</code> as the datatype for a "primary key", so I quickly added a new field to the <code>BlogPost</code> and added that to my seed data. But how to I make a button in <code>Angular</code> and then make a <code>DELETE</code> call to the controller with the id of the selected post?
<blockquote>
The second in a four-part series of posts on <a href="/series/technical-assessment-series">'An Assessment of a Technical Assessment'</a>.
</blockquote>
It was time for me to turn to the <a href="https://angular.io/tutorial">tutorial</a>. The Tour of Heroes tutorial on the Angular website certainly looked to be what I needed. I tried jumping straight to <a href="https://angular.io/tutorial/toh-pt6#delete-a-hero">"Delete a hero"</a>, but it's talking about services and delegates and... whoa. Ok, time to take it back to the top.
<h2>Refactoring the Template</h2>
I zipped back to the top of the tutorial and quickly made sense of a lot of the work that the initial Visual Studio template created for me. Much of what the early parts of the tutorial teach the user were refactors that I thought would be necessary, but I didn't know how to do it yet.
<ul>
<li>Refactor the <code>BlogPost</code> interface out to its own class.</li>
<li>Refactor the data retrieval into a <code>BlogPostService</code> and inject it into the component.</li>
<li>Rename the <code>home</code> component to be <code>blogpost</code> - it's still that I'm still using the generic name.</li>
<li>Refactor the <code>blogpost.component</code> to use the new service.</li>
</ul>
What do I get after all that refactoring? Exactly the same output - which is what I had hoped for. No new functionality has yet been added, but I feel better about where things are.
<img src="/images/techass-recent-blog-posts.png" alt="Recent Blog Posts">
<h2>Delete a ~~hero~~ Blog Post</h2>
<ol>
<li>Add a delete button and have it call a delete method.</li>
<li>Create a delete method and have it call the delete service.</li>
<li>Create a delete method in the service, and have it call the API server's delete method.</li>
</ol>
<img src="/images/techass-404-delete.png" alt="HTTP404: NOT FOUND on DELETE">
Oh, and I tried all kinds of things to get it to work. I tried explicitly setting the route in the attribute. I tried explicitly setting the action in the route. I tried using different action names in the URL. I tried turning it into a <code>GET</code> method. NOTHING WORKED!!! What was I doing so very wrong???
After a much longer time than I wish to admit, the problem was that I needed to put the id parameter in the attribute. Clearly I needed more coffee this evening.
<pre><code class="language-csharp">[HttpDelete("{id}")]
public void DeleteBlogPost(Guid id)
{
 new BlogPostService().DeleteBlogPost(id);
}
</code></pre>
From there, I was able to verify that the call made it into the <code>BlogPostService</code> that I had previously created. It properly removed the item from the original list and returned a <code>200:OK</code> response. All is well, and I am going to call this step complete. Once I get the entire front-end working, that's when I will handle persisting these changes to some storage medium. This part reminds me of my <a href="/posts/2016/user-can-create-new-patron/">User* Can Create**** New Patron*****</a> post from 2016.

Technical Assessment - Adding Delete Functionality

Yesterday, I did a phone interview with a company offering the possibility for a rather exciting position. The person I spoke with seemed very intelligent, articulate, passionate, and sold the organization well. It's a small organization that is growing, and is looking to consolidate all of their development work into their Chicago office instead of relying on developers in foreign countries. This feels very similar to <a href="/about">what I did</a> with Falkor Group and again with The Fellowship — start with a small team, map out a strategy for the next several sprints, then mentor and grow the team from there. Of course, the interview process is a two-way sales process, and they need to make sure that I can live up to expectations. This leads to why I am doing a Technical Assessment.
<blockquote>
The first in a four-part series of posts on <a href="/series/technical-assessment-series">'An Assessment of a Technical Assessment'</a>.
</blockquote>
The requirements are fairly straightforward.
<blockquote>
Technical Assessment
This assessment is intended to give us a better idea of your technical ability and code style as a developer. It will also give you an opportunity to learn about and utilize the tools we work with at the company.
Instructions
Create a dynamic blogging application that meets the following requirements:
<ul>
<li>Allow the user to view blog posts in chronological order</li>
<li>Allow the user to create a blog post</li>
<li>Allow the user to remove a blog post</li>
</ul>
Technologies
You must use the following technologies to complete this assessment:
<ul>
<li>.NET 4.6+ / .NET Core</li>
<li>Angular 5+</li>
<li>ngrx/store</li>
<li>Entity Framework</li>
<li>SQL Server</li>
</ul>
Notes
<ul>
<li>You do not have to implement user authentication into your solution</li>
<li>Your code should follow SOLID principles and make use of modern design patterns</li>
<li>Be prepared to explain your solution in depth</li>
</ul>
</blockquote>
<h2>Visual Studio -> New Solution</h2>
I set off right away to get working - this should be easy, right? I've never used <code>Angular</code> before (Knockout is the JavaScript framework of choice at The Fellowship), and I've never used <code>ngrx/store</code> (client state isn't that complicated in KesherNet). But Visual Studio has a template for creating a new ASP.NET Web Application using <code>.NET Core</code> and <code>Angular</code> - this should be super easy!
<img src="/images/techass-new-core-web-application.png" alt="New ASP.NET Core Web Application">
<ol>
<li>By the power vested in me, I command thee to build!</li>
<li>Oh, this project requires <code>Node.js</code> to build; so let's install that.</li>
<li>... lots of progress bars.</li>
<li>Great - now let's build and run this barebones project!</li>
<li>Internal Server Error? huh - well let's do a search for this error message "The NPM script 'start' exited without indicating that the Angular CLI was listening for requests."</li>
<li><a href="https://stackoverflow.com/a/53162998">This Stack Overflow answer looks promising</a>, I'll just do that.</li>
<li>... more progress bars. "MSBUILD : error MSB3428: Could not load the Visual C++ component "VCBuild.exe"." That can't be good.</li>
<li><a href="https://stackoverflow.com/a/39235952">Another Stack Overflow answer</a></li>
<li>... more progress bars. But it's all green text - so that should be good.</li>
<li>New let's build and run this barebones project!</li>
</ol>
<h2>Hello, World</h2>
<img src="/images/techass-hello-world.png" alt="Hello, World">
Well that worked out well enough - time to break this template down and make it do what I want.
The sample comes with three components - Home (display static content), Counter (show ability to modify non-persistent state on the page), and Fetch Data (demonstrate calling a Web API endpoint). I deleted the Home and Counter components, then renamed everything "Fetch Data" to "Home".
The initial object is a <code>WeatherForecast</code>, which I repurposed to be my <code>BlogPost</code> interface. The <code>component.html</code> is easy enough to repurpose to spit out the data coming from the controller. The new <code>HomeController</code> was refactored to return a collection of <code>BlogPost</code>. I added a second project to hold a <code>BlogPostService</code> which will handle the data retrieval. Later, this can be refactored to use EF and SQL Server to store and retrieve the data.
After throwing together some quick static seed data, the project was ready to go. I had a few typos and case sensitivities that needed correction. Once I got all of that straightened out - I finally had the initial pass at a "Recent Blog Posts" application.
<img src="/images/techass-recent-blog-posts.png" alt="Recent Blog Posts">

Technical Assessment - Requirements and First Pass

The last time I had an introspective post was in my <a href="/posts/2017/2017-year-in-review/">sign-off to 2017 post</a>. As I'm flying from Chicago to Toronto on a work trip, I felt inspired to write another piece. During the summer I came to the realization that I've reached the end of the growth that I can gain at The Fellowship, and that it is time for the next phase in my career. Over the last ten years, I have found what I am passionate about and now I need to find the right company with the culture that can support those passions and where we will have a mutually beneficial relationship.
<h2>The First Four Years at The Fellowship</h2>
Over the first four years, my title changed from "Senior .NET Developer" to ".NET Developer Team Lead" to "Manager of Application Development". Not a lot changed in my position description with each title change - more the title catching up to what I was actually doing. During the entire period I was reporting to the "Director of Information Services", who in turn reported to the COO. The Information Services department oversaw all technology related aspects of operations for the organization, split roughly between the Infrastructure team (which included the one-man helpdesk and the network engineer) and the App Dev team (a DBA, me, and a few jr. devs).
I had always been the senior most developer on the team, working in frequent and close collaboration with the DBA. My boss determined the priority of various projects that were in our pipeline, and I was tasked with ensuring that the day-to-day operations were being met while keeping the projects moving along. I handled most interactions with our users - be it for requirements gathering, user testing, user training, or general good will.
There were a couple of signature projects that I look back on fondly, including: overhauling the way receipts and letters are printed (replacing a manual Word mail-merge process with an automated PDF output), changing the way the entire organization spoke and looked at donor "contact preferences" (including architecting a new CRM module to better track and reflect these preferences), and moving our code base from web forms to ASP.NET MVC with Razor and from ADO.NET to DBMLs and then to Entity Framework. This was a period marked by a lot of wins and very few failures. I had a lot of time and freedom to experiment with new frameworks, to teach myself new technologies, and to help my team learn and grow.
By the time the one-year mark was coming up at the manager level, my career growth had seemed to stall. There were no more titles to squeeze in before moving to Director and there was no indication that an opening was going to happen.
<h2>One Fateful Week</h2>
The Fellowship has had a known problem internally of having a lack of project management on large initiatives. At this point, we were looking to move off of our web services / email marketing platform for a myriad number of reasons. However, there was no obvious department to lead and project manage this multi-phase, cross-department initiative. There were a few high-level discussions about who should take on that role, but the decision was lingering for weeks as various directors and departments demurred that they didn't have the bandwidth to fully take it on.
Eventually (from my understanding), the COO laid down a final call for ideas about who should take on the responsibility. When I heard about this, I spent my weekend putting together a comprehensive proposal for a new "Director of Technology" position and department that would combine my internal team of developers with the team of developers for our external website. This department's purpose would be to ensure that departments across The Fellowship had the best software tools and training that the organization could afford to help them be the best at their jobs. This would include market research, departmental interviews, handling bids and contracts, vendor management, and user training and support. It would also include project management for these cross-departmental initiatives such as just the one that we were about to engage in. I had outlined a transition plan, a budget, and preliminary measures of success. That Sunday evening and Monday morning, I lobbied hard for my boss, the "Director of Information Services", to pitch this proposal to his boss, the "Global Chief Operating Officer".
This was a position that I was extremely excited and passionate about. The more I studied similar positions at other organizations, wrote about it in my proposal, and envisioned how I could grow the department, I found a renewed sense of enthusiasm for the company. For the first time in a while, I came into the office excited and filled with a renewed sense of purpose. I had finally discovered, in a weekend of writing down one giant hypothetical, what I was passionate about and where I wanted to take my career. I was on an incredible high that week, giddy with a sense of what the future could hold.
<h2>An Unexpected, Disappointing Promotion</h2>
I hadn't heard anything during the week about whether my boss had actually done anything with my proposal, but I had faith in him and hoped that while he would lose me as a direct report, he would see that The Fellowship would be better for it and that I would be able to continue to grow instead of stagnate where I was. Friday morning came around and he pulled me into a conference room. Without preamble, he held out his hand and congratulated me on becoming the new "Director of Information Services".
"What. The. Fuck."
It was the only thought I had; I was completely dumbfounded. I didn't know what this was, but it was not good – not at all what I wanted. I kind-of-sort-of recovered, shook his hand, said my thanks, and then (very characteristically, but much more so than usual) skeptically asked where he was going. He was positively beaming and announced that he was being promoted to the brand new position of "Vice President of Technology" and that I would continue to be reporting to him.
"What. The. Fuck."
I just could not stop thinking it. I've never been so blindsided by news then I had in that moment. He went on to tell me that the infrastructure/helpdesk team would continue to report to him, but our DBA would be reporting to me. The Web Services department was being moved under him and a different director was given a lateral move to a new position to specifically project manage the email marketing platform and web services migration project. I spent the rest of the day in a complete haze. HR sent out an email announcing the various promotions. Everyone was congratulating me on the new opportunity, which (I think/hope) I managed to gracefully and humbly accept.
The weekend was a baffling mixture of emotions ranging from disappointment to anger to resignation to renewed belief that it was time for me to find another opportunity. I don't think I had a single honest moment of positivity about these organizational changes. I can only imagine how rough it was for my wife to see me go through all this. I can't even imagine how grumpy and hostile I must have been that weekend.
<h2>"I'll Give It a Year"</h2>
By the time I came into the office on Monday, I had convinced myself that I would give it a year. At a minimum, one year would look good on a resume. I felt that was a reasonable amount of time to guide and shape this modified department, to help the organization transition with the new structure, and to support my boss in his new role. It wasn't a lot, but it was something. It got me through that first week, and then the first month, and then through a lot of hard adjustments the company had to make during the first six months.
Looking back on the last 18 months, I can honestly say that I gave it my best effort. I have added a significant number of services that the IS team is able to provide to other departments. I have been able to transition almost the entirety of day-to-day operations onto my team. I have mentored them in how to better engage with the different needs and personalities of each department.
I architected a solution to create a secure API and pipeline to ingest data from the website, including processing credit cards and sending email confirmations. Throughout that project, I taught the developers why this was the right solution and the right design patterns. The foundation has been laid, and next is an expansion of the API into two-way communication for an upcoming greenfield Donor Portal project - giving our users a comprehensive online view of their account, one they've never had before. I've guided the team from being told what technologies and frameworks to use, to now ensuring they have the confidence and tools to search for or create the right solution.
<h2>In Conclusion, Continued...</h2>
Years ago, I was the only person who was able to look at a problem and understand what the entirety of the solution would be; now, my team is almost always able to get there on their own and they just come to me for confirmation. It is a satisfying sense of accomplishment to know where my team has come from and where I've taken them. Even as I see the growth they've achieved, I am worried that I have stalled my own growth. At conferences that I've been to, I feel as if I'm slipping further behind my peers in knowledge share, community engagement, and breadth of impact. I want to go back to working on Big Projects that have significant positive impacts on whole organizations. I want to foster and mentor another team of developers. I want to explore and experiment on a grander scale.
I am really good at my job; but is my job still really good for me?

My Time at The Fellowship

Remembering what to pack, what clothes to wear, and what device accessories to bring has never been a problem for me. What inevitably causes me problems is attempting to do some work in that dreaded space of time when I am Without Internet. It's a terrible place to be, filled with unanswerable questions, un-updatable packages, unreviewable documentation, unwatchable shows and movies; and possibly worst of all, untouchable code repositories. Below are the list of items that I always need to remember to do the day before any planned travel - be it by car or by airplane - because time without internet access doesn't have to be wasted time browsing a magazine or reading a book or practicing Italian on Duolingo.
<h2>Laptop Updates</h2>
<ol>
<li>Open Visual Studio Code and ensure everything is up-to-date</li>
<li>Check for VS Code updates</li>
<li>Sync local repository with <code>origin</code></li>
<li>Update the Linux subsystem, update all gems, and verify that Jekyll will serve this blog
1. <code>sudo apt-get update -y &#x26;&#x26; sudo apt-get upgrade -y &#x26;&#x26; sudo apt-get autoremove -y</code>
1. <code>sudo gem update</code>
1. <code>bundle exec jekyll serve</code></li>
<li>Verify that Visual Studio is up-to-date, including all extensions</li>
<li>Sync local repository with <code>origin</code></li>
<li>Download some shows and a movie to Netflix</li>
<li>Download some playlists to Spotify</li>
<li>Reboot a couple of times, just to make sure everything is still working</li>
</ol>

Pre-Trip Checklist - Because If I Don't Write It Down...

Something that I've continuously struggled with in getting projects off the ground is finding a way to handle Authentication. Just the thought of building out a User Portal to handle Contact Information and Password Resets has killed many projects before they've even started. Worrying about how to best store passwords and how to securely log users into the application have halted progress on most of the Grand Ideas that I have had. However, since the Vigil project is something that I am truly excited about, it was time to find a solution that I could quickly piece together for most any project and offload as much of the responsibilities to another party as possible. I found my answer in <a href="https://docs.microsoft.com/en-us/azure/active-directory-b2c/active-directory-b2c-overview">AAD B2C</a>.
<blockquote>
Azure Active Directory (Azure AD) B2C is an identity management service that enables you to customize and control how customers sign up, sign in, and manage their profiles when using your applications. This includes applications developed for iOS, Android, and .NET, among others. Azure AD B2C enables these actions while protecting your customer identities at the same time.
</blockquote>
<h2>Azure Active Directory B2C</h2>
The documentation for Azure AD B2C is really quite thorough - there are immediate tutorials for writing an application in <a href="https://docs.microsoft.com/en-us/azure/active-directory-b2c/active-directory-b2c-tutorials-web-app">ASP.NET</a>, a <a href="https://docs.microsoft.com/en-us/azure/active-directory-b2c/active-directory-b2c-tutorials-desktop-app">Windows desktop application</a>, or a <a href="https://docs.microsoft.com/en-us/azure/active-directory-b2c/active-directory-b2c-tutorials-spa">single page app</a> on Node.js. Additional tutorials for other development environments can usually be found pretty easily (such as <a href="https://azure.microsoft.com/en-us/resources/samples/active-directory-b2c-php-webapp-openidconnect/">PHP</a>). What is truly solid about the solution is how frictionless the initial start-up was for my project. Since I am build an ASP.NET Core solution, Microsoft has already built a library that handles the UI for me, too. It really couldn't have been easier.
All of the code came as part of the default ASP.NET Code Web Application template that is built into Visual Studio 2017.
<img src="/images/vs2017-new-aspnet-code-web-application-individual-user-accounts.png" alt="Visual Studio 2017 New ASP.NET Code Web Application with Individual User Accounts authentication">
<h2>User Secrets</h2>
The other significant advancement in my project start-up task list was the ability to find a place for secrets and connection strings that don't belong in the source files. During testing, the callback URL for the application is localhost. This means that anyone would be able to download the source and run the code and be able to use my instance of AADB2C to store accounts - this is not an ideal solution. Instead, I can move the values for the ClientId and Domain into User Secrets! The <code>appsettings.json</code> file can have any values in the ClientId and Domain properties. In fact, they don't even need to be present. I like to put them there as a way to remind developers where the values should go. It would be terrible if someone thought the properties were missing, "helpfully" checked them in, and then blew the whole secret.
<pre><code class="language-json">{
 "AzureAdB2C": {
 "Instance": "https://login.microsoftonline.com/tfp/",
 "ClientId": "&#x3C;!-- stored as a secret -->",
 "Domain": "&#x3C;!-- stored as a secret -->",
 "CallbackPath": "/signin-oidc",
 "SignUpSignInPolicyId": "B2C_1_SiUpIn",
 "ResetPasswordPolicyId": "B2C_1_SSPR",
 "EditProfilePolicyId": "B2C_1_SiPe",
 },
 "Logging": {
 "LogLevel": {
 "Default": "Warning"
 }
 }
}
</code></pre>
In Visual Studio, it is a simple right-click on the project, and select Manage User Secrets.
<img src="/images/vs2017-inavord-manage-user-secrets.png" alt="Visual Studio 2017 Manage User Secrets">
This will bring up the <code>secrets.json</code> file for the local computer. There <a href="https://docs.microsoft.com/en-us/aspnet/core/security/app-secrets">are caveats</a> to using this method of storage, namely that it isn't actually secure. These settings are generally stored in plain text on the filesystem. What is key is that they are not stored in a location that might get it pushed into source control.
<pre><code class="language-json">{
 "AzureAdB2C": {
 "ClientId": "00000000-0000-0000-0000-000000000000",
 "Domain": "adb2c-subdomain.onmicrosoft.com"
 }
}
</code></pre>
The values for these properties are pulled directly from the Azure portal.
<img src="/images/azure-adb2c-application-properties.png" alt="Azure AD B2C Application Properties">
<h2>Authentication and Secrets</h2>
Each time I pull down the solution to a new computer, or if I need to change the Application ID or the Doman name, then I need to update the values in the locally stored secrets. This is an inconvenience I can deal with as a way to no longer worry about accidentally checking them into source control.
Pulled together, this really jump starts the prospects of having the knowledge to quickly pull together a project in the future. It starts with this, and as I continue to build on the basics, I plan to keep updating this series.

Rovani's Sandbox

Blog Posts - Page 5