Anglebrackets Conference – Day 2

I have been fortunate to attend this year’s Anglebrackets conference in Las Vegas. (See my coverage of Day 1 here.)
The following are my notes from the Day 2 keynote, The Integration of Technologies with Office 365. The speaker: Rob Leffers, the director of program management for the Office 365 apps team.
– Our vision
– What’s next
– Futures
– Calls to action
– Office
– Visual Studio
– Azure
Connect to Office 365 services
– Users and groups
– Files
– Mail
– Calendar
– Contacts
Build using an open platform
– Azure
– .Net
– Android
– iOS
– Html5
– Xamarin
Robust Office 365 APIs
– designed for openness and flexibility
– Consistent development platform
– Powering a world of devices

Demo: IFTTT recepies for OneDrive
Demo: signing into iPhone app using Azure AD
Demo: API Sandbox at
Where we are:
– Launched “re imagine office” campaign
– 3,4 millions Office developers
– 1 million Sharepoint Developers
– Over 1200 apps
– 3.5 million downloads
– 142 new markets
– 400 petabytes of storage
– Expand
– Unified APIs
– Mobile
Demo: application for Office
– Downloaded app: “api tutorial” in Excel. App is using Javascript to work with Office (Excel) API
We listening
– Office client coverage
– Deploy across Office 365 web ui
– More Sharepoint APIs and Office APIs
– Simplified authentication and authorization (use Azure AD)
Demo: Office app launcher in Azure portal (in Azure AD). Demo Azure AD with list of office apps and permissions.
Application acquisition:
– Tenant registered app through Azure portal
– Signing into web app with Office 365 credentials
– From office store
Demo: Azure management portal.
Demo: creating Office 365 app in Visual Studio. Select APIs and access priveleges.
– Xamarin and Cordoba
– Native SDKs
Demo: property manager app for iOS. Web (MVC), iOS and uses Sharepoint document collection to store items, uses Sharepoint workflow.
Demo: research tracker (bookmark manager). Web(angular) + android.
Coming up:
Demo: file extensions. Assign app to file extension in SP.
Microsoft graph. Unified API endpoint for all Office APIs.
Demo: excel app on iPad. Same as on PC or mac.

Session: Visual Studio 2013 and state of the web
Speaker: Mohit Srivastava
Team: Azure dev experience. ASP.NET , Azure SDKs, dev service, niget, azure redis cache
Only one, single framework – ASP.NET
ASP.NET and web tools Release carence – every 6 months, something every 3-4
Web essencials ( – from web tools labs, release every 2 months
Shipped last months
– new identity system
– All templates bootstrap
– New “file: new” scaffolding
– Azure SDK
– WEB apis: CORs, attribute routing
– MVC – attribute routing
– EF: asnc, stored procs, resiliency
– VS: new html editor, browser link, page inspector, angularjs intellisense
– Fast (little overhead)
– Side-by-side, ccompletely isolated deployment
– Modular
– Cloud ready
– Fast development
– Breaking change
– Open source
– Cross-platform
– Mvc and web api merged
– EF: nosql
– VS: new projet system, grunt, bower, npm
– VS 2013 project creation with OpenAuth and Azure web site hosting
Manage azure web sites right from VS
View azure logs from VS
Attach VS debugger to Azure
VS CRUD scaffolding
Postman for WebAPI testing
DB migration
Browser link: Ctrl-alt-Enter tot refresh connected browsers. Need web essentials.

Session: A practical view of release management in Visual Studio
Speaker: Donavan Brown, Technology specialist, Microsoft
DevOps 3 pillars:
– People
– Process
– Products
How it works:
RM Web
RM Desktop
RM Server
Drop location
Deployment options
– agent based deployment
– Desired State Configuration, DSC (powershell)
– Chef (Linux)
What is DSC?
– Start with description of desired state
– Get.Test.Set to get to desired state
– Description could be stored in TFS
– Shard gallery of DSC resources
– DSC is a domain specific languare on top of Powershell
– Starting point: DB project, MVC app, Coded YU tests, unit tests, WPF app, Setup (msi)
– make changes and check in
– automatic build is run
– TFS release management – build approved and moved
– release template
– You can add your own deployment tools to RM

Session: AngularJS patterns for building business apps
Speaker – John Papa
9 angular facts
1. Structuring your code. Structure patterns:
a. By type
b. By feature
c. Hybrid
Be consistent
LIFT principle
– Locating is easy
– Identify code at a glance
– Flat structure as long as you can
– Try to stay DRY
2. Data patterns. Separation of concerns
Controllers defer data calls to data service/factory
$http – like $.ajax. Returns promise (.then)
Isolate shared pieces
Don’t put data access into controller
3. Exception handling patterns
– Catch and handle all exceptions
– Local (console) and remote logging. Remote logging should be fire and forget
– Decorate $exceptionHandler service. I.e. extend standard exception handler. Add metadata to exception, log error.
4. Modularity
– Each module can be app, service or view
– Or all
– Modules can depend on each other
– Promotes continuous development
– Modules are like namespaces in .net
– Defined using angular.module(‘myapp’, []);
– Injecting dependencies into modules angular.module(‘myapp’, ‘’);
– Modules are good to separate workstreams
5. Controller patterns
– Javascript constructors (which is a function). Controller needs a contructor.
Angular.module(‘app.avengers’).controller(‘avenger’, Avenger);
Function Avenger() { … } // controller
– Use controller to specifically address specific controller
– In case of nested controllers, don’t address $scope directly, add $scope.vm and then add property to it
6. Clean code
– Don’t use anonymous functions, use named, it’s easier to debug
– Use (function() { }) (immediately invoked function expression) to avoid that named function to become global
7. Dependency injection
– To safely minify, use inline dependency arrey for dependency injection.
– Or use $inject. Preferred.
Angular file templates
Sublime text
8. Tasks and annotations
– Automation is great. Grunt or Gulp.
– Inject later with ngAnnotate (sort of declarative attribute)
9. Breeze, local storage, validation, karma, gulp and more

Session: Full stack web performance
Speaker – Nik Molnar
Co-founder of Glimpse – diagnostic platform for web, performance mostly
Why performance matter?
Amazon – lost %1 of sales for 1 ms of delay
Mobile – resources are limited
User hierarchy of needs
– Functional
– Reliable
– Usable
– Performant
– Pleasurable
Attack plan (for performance):
1. Measurable improvements (measure twice – get the same results)
2. Platform stability
3. Environment neutrality
4. Scenario focused
5. Preset goals (reach set goals)
6. Descending granularity (start with biggest problems first)
In general in web applications, most important reasons (greater granularity):
1. Network
a. Fewer requests
b. Smaller payloads
c. Procrastinate (lazy)
d. Anticipate (pre-render)
Demo: Chrome dev tools, network tab, HAR format, online har viewer. PageSpeed extension.
– ASP.NET bundling
– Enable Compression in system.webserver, both static and dynamic
– Enable caching (same place)
– Use web essencials to clreate image sprite
– Embed smaller images into css as Base64, use web essencials
– <script async>
– <img lazyload=”1″>
– Prebrowsing
○ <link rel=”dns-prefetch”
○ <link rel=”prefetch”
○ <link rel=”prerender”
2. Server
– Stay local (in process)
– Iterate less
– Cache liberally
– Stream (don’t data load at once)
– Mics
○ String builder
○ No exceptions
○ Build in release
3. Compute
– Optimize JS execution. Demo: Profile in Chrome dev tools
– Scope management
○ Favor local vas (use var keyword)
○ Avoid with() statement
○ Careful with closures – don’t access gobal vars from inside closure, access less, if possible
– Looping
○ Avoid for .. In loops
– Avoid writing and reading DOM at the same time, optimize rendering timing,

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Stan Tarnovskiy

Solutions Architect at Perficient

More from this Author

Subscribe to the Weekly Blog Digest:

Sign Up
Follow Us